commit 18ad263272038fdf1c1634e2b51a64284ef4957c · pyrox.dev/nixpkgs

+1 -1

nixos/lib/make-zfs-image.nix

···

       241
       241
        
           pkgs.vmTools.override {

     

       242
       242
        
             rootModules =

     

       243
       243
        
               [ "zfs" "9p" "9pnet_virtio" "virtio_pci" "virtio_blk" ] ++

     

       244
       244
       -
                 (pkgs.lib.optional (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) "rtc_cmos");

     

       244
       244
       +
                 (pkgs.lib.optional pkgs.stdenv.hostPlatform.isx86 "rtc_cmos");

     

       245
       245
        
             kernel = modulesTree;

     

       246
       246
        
           }

     

       247
       247
        
         ).runInLinuxVM (

+1 -1

nixos/lib/qemu-common.nix

···

       17
       17
        
             ''-netdev vde,id=vlan${toString nic},sock="$QEMU_VDE_SOCKET_${toString net}"''

     

       18
       18
        
           ];

     

       19
       19
        
       

     

       20
       20
       -
         qemuSerialDevice = if pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64 then "ttyS0"

     

       20
       20
       +
         qemuSerialDevice = if pkgs.stdenv.hostPlatform.isx86 then "ttyS0"

     

       21
       21
        
               else if (with pkgs.stdenv.hostPlatform; isAarch32 || isAarch64 || isPower) then "ttyAMA0"

     

       22
       22
        
               else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";

     

       23
       23

+1 -1

nixos/modules/hardware/all-firmware.nix

···

       83
       83
        
               b43Firmware_5_1_138

     

       84
       84
        
               b43Firmware_6_30_163_46

     

       85
       85
        
               b43FirmwareCutter

     

       86
       86
       -
             ] ++ optional (pkgs.stdenv.hostPlatform.isi686 || pkgs.stdenv.hostPlatform.isx86_64) facetimehd-firmware;

     

       86
       86
       +
             ] ++ optional pkgs.stdenv.hostPlatform.isx86 facetimehd-firmware;

     

       87
       87
        
           })

     

       88
       88
        
           (mkIf cfg.wirelessRegulatoryDatabase {

     

       89
       89
        
             hardware.firmware = [ pkgs.wireless-regdb ];

+1 -1

nixos/modules/installer/cd-dvd/iso-image.nix

···

       467
       467
        
             throw "Unsupported architecture";

     

       468
       468
        
       

     

       469
       469
        
         # Syslinux (and isolinux) only supports x86-based architectures.

     

       470
       470
       -
         canx86BiosBoot = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       470
       470
       +
         canx86BiosBoot = pkgs.stdenv.hostPlatform.isx86;

     

       471
       471
        
       

     

       472
       472
        
       in

     

       473
       473

+1 -1

nixos/modules/system/boot/kernel.nix

···

       243
       243
        
                   "hid_generic" "hid_lenovo" "hid_apple" "hid_roccat"

     

       244
       244
        
                   "hid_logitech_hidpp" "hid_logitech_dj" "hid_microsoft"

     

       245
       245
        
       

     

       246
       246
       -
                 ] ++ optionals (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) [

     

       246
       246
       +
                 ] ++ optionals pkgs.stdenv.hostPlatform.isx86 [

     

       247
       247
        
                   # Misc. x86 keyboard stuff.

     

       248
       248
        
                   "pcips2" "atkbd" "i8042"

     

       249
       249

+1 -1

nixos/modules/virtualisation/azure-agent.nix

···

       76
       76
        
       

     

       77
       77
        
         config = mkIf cfg.enable {

     

       78
       78
        
           assertions = [ {

     

       79
       79
       -
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       79
       79
       +
             assertion = pkgs.stdenv.hostPlatform.isx86;

     

       80
       80
        
             message = "Azure not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       81
       81
        
           } {

     

       82
       82
        
             assertion = config.networking.networkmanager.enable == false;

+3 -3

nixos/modules/virtualisation/qemu-vm.nix

···

       97
       97
        
           imap1 (idx: drive: drive // { device = driveDeviceName idx; });

     

       98
       98
        
       

     

       99
       99
        
         efiPrefix =

     

       100
       100
       -
           if (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) then "${pkgs.OVMF.fd}/FV/OVMF"

     

       100
       100
       +
           if pkgs.stdenv.hostPlatform.isx86 then "${pkgs.OVMF.fd}/FV/OVMF"

     

       101
       101
        
           else if pkgs.stdenv.isAarch64 then "${pkgs.OVMF.fd}/FV/AAVMF"

     

       102
       102
        
           else throw "No EFI firmware available for platform";

     

       103
       103
        
         efiFirmware = "${efiPrefix}_CODE.fd";

     
···

       296
       296
        
           virtualisation.memorySize =

     

       297
       297
        
             mkOption {

     

       298
       298
        
               type = types.ints.positive;

     

       299
       299
       -
               default = 384;

     

       299
       299
       +
               default = 1024;

     

       300
       300
        
               description =

     

       301
       301
        
                 ''

     

       302
       302
        
                   The memory size in megabytes of the virtual machine.

     
···

       833
       833
        
       

     

       834
       834
        
           # FIXME: Consolidate this one day.

     

       835
       835
        
           virtualisation.qemu.options = mkMerge [

     

       836
       836
       -
             (mkIf (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) [

     

       836
       836
       +
             (mkIf pkgs.stdenv.hostPlatform.isx86 [

     

       837
       837
        
               "-usb" "-device usb-tablet,bus=usb-bus.0"

     

       838
       838
        
             ])

     

       839
       839
        
             (mkIf (pkgs.stdenv.isAarch32 || pkgs.stdenv.isAarch64) [

+1 -1

nixos/modules/virtualisation/virtualbox-guest.nix

···

       33
       33
        
       

     

       34
       34
        
         config = mkIf cfg.enable (mkMerge [{

     

       35
       35
        
           assertions = [{

     

       36
       36
       -
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       36
       36
       +
             assertion = pkgs.stdenv.hostPlatform.isx86;

     

       37
       37
        
             message = "Virtualbox not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       38
       38
        
           }];

     

       39
       39

+1 -1

nixos/modules/virtualisation/vmware-guest.nix

···

       23
       23
        
       

     

       24
       24
        
         config = mkIf cfg.enable {

     

       25
       25
        
           assertions = [ {

     

       26
       26
       -
             assertion = pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64;

     

       26
       26
       +
             assertion = pkgs.stdenv.hostPlatform.isx86;

     

       27
       27
        
             message = "VMWare guest is not currently supported on ${pkgs.stdenv.hostPlatform.system}";

     

       28
       28
        
           } ];

     

       29
       29

-4

nixos/tests/airsonic.nix

···

       11
       11
        
               enable = true;

     

       12
       12
        
               maxMemory = 800;

     

       13
       13
        
             };

     

       14
       14
       -
       

     

       15
       15
       -
             # Airsonic is a Java application, and unfortunately requires a significant

     

       16
       16
       -
             # amount of memory.

     

       17
       17
       -
             virtualisation.memorySize = 1024;

     

       18
       14
        
           };

     

       19
       15
        
       

     

       20
       16
        
         testScript = ''

-1

nixos/tests/cage.nix

···

       17
       17
        
             program = "${pkgs.xterm}/bin/xterm -cm -pc -fa Monospace -fs 24";

     

       18
       18
        
           };

     

       19
       19
        
       

     

       20
       20
       -
           virtualisation.memorySize = 1024;

     

       21
       20
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Cage can launch:

     

       22
       21
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       23
       22
        
         };

-1

nixos/tests/cagebreak.nix

···

       35
       35
        
           programs.xwayland.enable = true;

     

       36
       36
        
           environment.systemPackages = [ pkgs.cagebreak pkgs.wayland-utils ];

     

       37
       37
        
       

     

       38
       38
       -
           virtualisation.memorySize = 1024;

     

       39
       38
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Cagebreak can launch:

     

       40
       39
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       41
       40
        
         };

-1

nixos/tests/cassandra.nix

···

       41
       41
        
             ];

     

       42
       42
        
           };

     

       43
       43
        
           services.cassandra = cassandraCfg ipAddress // extra;

     

       44
       44
       -
           virtualisation.memorySize = 1024;

     

       45
       44
        
         };

     

       46
       45
        
       in

     

       47
       46
        
       {

-1

nixos/tests/ceph-multi-node.nix

···

       37
       37
        
       

     

       38
       38
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       39
       39
        
           virtualisation = {

     

       40
       40
       -
             memorySize = 1024;

     

       41
       40
        
             emptyDiskImages = [ 20480 ];

     

       42
       41
        
             vlans = [ 1 ];

     

       43
       42
        
           };

-1

nixos/tests/ceph-single-node-bluestore.nix

···

       34
       34
        
       

     

       35
       35
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       36
       36
        
           virtualisation = {

     

       37
       37
       -
             memorySize = 1024;

     

       38
       37
        
             emptyDiskImages = [ 20480 20480 20480 ];

     

       39
       38
        
             vlans = [ 1 ];

     

       40
       39
        
           };

-1

nixos/tests/ceph-single-node.nix

···

       34
       34
        
       

     

       35
       35
        
         generateHost = { pkgs, cephConfig, networkConfig, ... }: {

     

       36
       36
        
           virtualisation = {

     

       37
       37
       -
             memorySize = 1024;

     

       38
       37
        
             emptyDiskImages = [ 20480 20480 20480 ];

     

       39
       38
        
             vlans = [ 1 ];

     

       40
       39
        
           };

-1

nixos/tests/common/wayland-cage.nix

···

       8
       8
        
         };

     

       9
       9
        
       

     

       10
       10
        
         virtualisation = {

     

       11
       11
       -
           memorySize = 1024;

     

       12
       11
        
           qemu.options = [ "-vga virtio" ];

     

       13
       12
        
         };

     

       14
       13
        
       }

-1

nixos/tests/containers-bridge.nix

···

       15
       15
        
           { pkgs, ... }:

     

       16
       16
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       17
       17
        
             virtualisation.writableStore = true;

     

       18
       18
       -
             virtualisation.memorySize = 768;

     

       19
       18
        
       

     

       20
       19
        
             networking.bridges = {

     

       21
       20
        
               br0 = {

-1

nixos/tests/containers-ephemeral.nix

···

       5
       5
        
         };

     

       6
       6
        
       

     

       7
       7
        
         machine = { pkgs, ... }: {

     

       8
       8
       -
           virtualisation.memorySize = 768;

     

       9
       8
        
           virtualisation.writableStore = true;

     

       10
       9
        
       

     

       11
       10
        
           containers.webserver = {

-1

nixos/tests/containers-extra_veth.nix

···

       8
       8
        
           { pkgs, ... }:

     

       9
       9
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       10
       10
        
             virtualisation.writableStore = true;

     

       11
       11
       -
             virtualisation.memorySize = 768;

     

       12
       11
        
             virtualisation.vlans = [];

     

       13
       12
        
       

     

       14
       13
        
             networking.useDHCP = false;

-1

nixos/tests/containers-hosts.nix

···

       7
       7
        
         machine =

     

       8
       8
        
           { lib, ... }:

     

       9
       9
        
           {

     

       10
       10
       -
             virtualisation.memorySize = 256;

     

       11
       10
        
             virtualisation.vlans = [];

     

       12
       11
        
       

     

       13
       12
        
             networking.bridges.br0.interfaces = [];

-1

nixos/tests/containers-imperative.nix

···

       14
       14
        
             nix.binaryCaches = []; # don't try to access cache.nixos.org

     

       15
       15
        
       

     

       16
       16
        
             virtualisation.writableStore = true;

     

       17
       17
       -
             virtualisation.memorySize = 1024;

     

       18
       17
        
             # Make sure we always have all the required dependencies for creating a

     

       19
       18
        
             # container available within the VM, because we don't have network access.

     

       20
       19
        
             virtualisation.additionalPaths = let

-1

nixos/tests/containers-ip.nix

···

       22
       22
        
             imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       23
       23
        
             virtualisation = {

     

       24
       24
        
               writableStore = true;

     

       25
       25
       -
               memorySize = 768;

     

       26
       25
        
             };

     

       27
       26
        
       

     

       28
       27
        
             containers.webserver4 = webserverFor "10.231.136.1" "10.231.136.2";

-2

nixos/tests/containers-macvlans.nix

···

       15
       15
        
           machine1 =

     

       16
       16
        
             { lib, ... }:

     

       17
       17
        
             {

     

       18
       18
       -
               virtualisation.memorySize = 256;

     

       19
       18
        
               virtualisation.vlans = [ 1 ];

     

       20
       19
        
       

     

       21
       20
        
               # To be able to ping containers from the host, it is necessary

     
···

       55
       54
        
           machine2 =

     

       56
       55
        
             { ... }:

     

       57
       56
        
             {

     

       58
       58
       -
               virtualisation.memorySize = 256;

     

       59
       57
        
               virtualisation.vlans = [ 1 ];

     

       60
       58
        
             };

     

       61
       59

-4

nixos/tests/containers-physical_interfaces.nix

···

       7
       7
        
         nodes = {

     

       8
       8
        
           server = { ... }:

     

       9
       9
        
             {

     

       10
       10
       -
               virtualisation.memorySize = 256;

     

       11
       10
        
               virtualisation.vlans = [ 1 ];

     

       12
       11
        
       

     

       13
       12
        
               containers.server = {

     
···

       23
       22
        
               };

     

       24
       23
        
             };

     

       25
       24
        
           bridged = { ... }: {

     

       26
       26
       -
             virtualisation.memorySize = 128;

     

       27
       25
        
             virtualisation.vlans = [ 1 ];

     

       28
       26
        
       

     

       29
       27
        
             containers.bridged = {

     
···

       41
       39
        
           };

     

       42
       40
        
       

     

       43
       41
        
           bonded = { ... }: {

     

       44
       44
       -
             virtualisation.memorySize = 128;

     

       45
       42
        
             virtualisation.vlans = [ 1 ];

     

       46
       43
        
       

     

       47
       44
        
             containers.bonded = {

     
···

       62
       59
        
           };

     

       63
       60
        
       

     

       64
       61
        
           bridgedbond = { ... }: {

     

       65
       65
       -
             virtualisation.memorySize = 128;

     

       66
       62
        
             virtualisation.vlans = [ 1 ];

     

       67
       63
        
       

     

       68
       64
        
             containers.bridgedbond = {

-1

nixos/tests/containers-portforward.nix

···

       15
       15
        
           { pkgs, ... }:

     

       16
       16
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       17
       17
        
             virtualisation.writableStore = true;

     

       18
       18
       -
             virtualisation.memorySize = 768;

     

       19
       18
        
       

     

       20
       19
        
             containers.webserver =

     

       21
       20
        
               { privateNetwork = true;

-1

nixos/tests/containers-tmpfs.nix

···

       8
       8
        
           { pkgs, ... }:

     

       9
       9
        
           { imports = [ ../modules/installer/cd-dvd/channel.nix ];

     

       10
       10
        
             virtualisation.writableStore = true;

     

       11
       11
       -
             virtualisation.memorySize = 768;

     

       12
       11
        
       

     

       13
       12
        
             containers.tmpfs =

     

       14
       13
        
               {

-2

nixos/tests/custom-ca.nix

···

       81
       81
        
       

     

       82
       82
        
             # chromium-based browsers refuse to run as root

     

       83
       83
        
             test-support.displayManager.auto.user = "alice";

     

       84
       84
       -
             # browsers may hang with the default memory

     

       85
       85
       -
             virtualisation.memorySize = 500;

     

       86
       84
        
       

     

       87
       85
        
             networking.hosts."127.0.0.1" = [ "good.example.com" "bad.example.com" ];

     

       88
       86
        
             security.pki.certificateFiles = [ "${example-good-cert}/ca.crt" ];

-1

nixos/tests/enlightenment.nix

···

       19
       19
        
             };

     

       20
       20
        
           };

     

       21
       21
        
           hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       22
       22
       -
           virtualisation.memorySize = 1024;

     

       23
       22
        
           environment.systemPackages = [ pkgs.xdotool ];

     

       24
       23
        
           services.acpid.enable = true;

     

       25
       24
        
           services.connman.enable = true;

-1

nixos/tests/fcitx/default.nix

···

       11
       11
        
                 ...

     

       12
       12
        
               }:

     

       13
       13
        
                 {

     

       14
       14
       -
                   virtualisation.memorySize = 1024;

     

       15
       14
        
       

     

       16
       15
        
                   imports = [

     

       17
       16
        
                     ../common/user-account.nix

-1

nixos/tests/fenics.nix

···

       38
       38
        
               gcc

     

       39
       39
        
               (python3.withPackages (ps: with ps; [ fenics ]))

     

       40
       40
        
             ];

     

       41
       41
       -
             virtualisation.memorySize = 512;

     

       42
       41
        
           };

     

       43
       42
        
         };

     

       44
       43
        
         testScript =

-3

nixos/tests/firefox.nix

···

       13
       13
        
               pkgs.xdotool

     

       14
       14
        
             ];

     

       15
       15
        
       

     

       16
       16
       -
             # Need some more memory to record audio.

     

       17
       17
       -
             virtualisation.memorySize = 500;

     

       18
       18
       -
       

     

       19
       16
        
             # Create a virtual sound device, with mixing

     

       20
       17
        
             # and all, for recording audio.

     

       21
       18
        
             boot.kernelModules = [ "snd-aloop" ];

-1

nixos/tests/gerrit.nix

···

       18
       18
        
             { config, pkgs, ... }: {

     

       19
       19
        
               networking.firewall.allowedTCPPorts = [ 80 2222 ];

     

       20
       20
        
       

     

       21
       21
       -
               virtualisation.memorySize = 1024;

     

       22
       21
        
       

     

       23
       22
        
               services.gerrit = {

     

       24
       23
        
                 enable = true;

-1

nixos/tests/gnome-xorg.nix

···

       40
       40
        
               };

     

       41
       41
        
             };

     

       42
       42
        
       

     

       43
       43
       -
             virtualisation.memorySize = 1024;

     

       44
       43
        
           };

     

       45
       44
        
       

     

       46
       45
        
         testScript = { nodes, ... }: let

-1

nixos/tests/gnome.nix

···

       45
       45
        
               };

     

       46
       46
        
             };

     

       47
       47
        
       

     

       48
       48
       -
             virtualisation.memorySize = 1024;

     

       49
       48
        
           };

     

       50
       49
        
       

     

       51
       50
        
         testScript = { nodes, ... }: let

-1

nixos/tests/graphite.nix

···

       4
       4
        
         nodes = {

     

       5
       5
        
           one =

     

       6
       6
        
             { ... }: {

     

       7
       7
       -
               virtualisation.memorySize = 1024;

     

       8
       7
        
               time.timeZone = "UTC";

     

       9
       8
        
               services.graphite = {

     

       10
       9
        
                 web = {

-2

nixos/tests/hadoop/hadoop.nix

···

       95
       95
        
       

     

       96
       96
        
           # YARN cluster

     

       97
       97
        
           rm1 = {pkgs, options, ...}: {

     

       98
       98
       -
             virtualisation.memorySize = 1024;

     

       99
       98
        
             services.hadoop = {

     

       100
       99
        
               inherit package coreSite hdfsSite;

     

       101
       100
        
               yarnSite = options.services.hadoop.yarnSite.default // yarnSiteHA;

     
···

       103
       102
        
             };

     

       104
       103
        
           };

     

       105
       104
        
           rm2 = {pkgs, options, ...}: {

     

       106
       106
       -
             virtualisation.memorySize = 1024;

     

       107
       105
        
             services.hadoop = {

     

       108
       106
        
               inherit package coreSite hdfsSite;

     

       109
       107
        
               yarnSite = options.services.hadoop.yarnSite.default // yarnSiteHA;

-1

nixos/tests/hadoop/hdfs.nix

···

       2
       2
        
       import ../make-test-python.nix ({...}: {

     

       3
       3
        
         nodes = {

     

       4
       4
        
           namenode = {pkgs, ...}: {

     

       5
       5
       -
             virtualisation.memorySize = 1024;

     

       6
       5
        
             services.hadoop = {

     

       7
       6
        
               package = pkgs.hadoop;

     

       8
       7
        
               hdfs = {

-1

nixos/tests/installed-tests/fwupd.nix

···

       7
       7
        
           services.fwupd.enable = true;

     

       8
       8
        
           services.fwupd.disabledPlugins = lib.mkForce []; # don't disable test plugin

     

       9
       9
        
           services.fwupd.enableTestRemote = true;

     

       10
       10
       -
           virtualisation.memorySize = 768;

     

       11
       10
        
         };

     

       12
       11
        
       }

+1 -1

nixos/tests/installer.nix

···

       70
       70
        
           let iface = if grubVersion == 1 then "ide" else "virtio";

     

       71
       71
        
               isEfi = bootLoader == "systemd-boot" || (bootLoader == "grub" && grubUseEfi);

     

       72
       72
        
               bios  = if pkgs.stdenv.isAarch64 then "QEMU_EFI.fd" else "OVMF.fd";

     

       73
       73
       -
           in if !isEfi && !(pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) then

     

       73
       73
       +
           in if !isEfi && !pkgs.stdenv.hostPlatform.isx86 then

     

       74
       74
        
             throw "Non-EFI boot methods are only supported on i686 / x86_64"

     

       75
       75
        
           else ''

     

       76
       76
        
             def assemble_qemu_flags():

-1

nixos/tests/jitsi-meet.nix

···

       8
       8
        
           client = { nodes, pkgs, ... }: {

     

       9
       9
        
           };

     

       10
       10
        
           server = { config, pkgs, ... }: {

     

       11
       11
       -
             virtualisation.memorySize = 512;

     

       12
       11
        
             services.jitsi-meet = {

     

       13
       12
        
               enable = true;

     

       14
       13
        
               hostName = "server";

-1

nixos/tests/kafka.nix

···

       19
       19
        
               };

     

       20
       20
        
       

     

       21
       21
        
               networking.firewall.allowedTCPPorts = [ 2181 ];

     

       22
       22
       -
               virtualisation.memorySize = 1024;

     

       23
       22
        
             };

     

       24
       23
        
             kafka = { ... }: {

     

       25
       24
        
               services.apache-kafka = {

-1

nixos/tests/keycloak.nix

···

       17
       17
        
       

     

       18
       18
        
             nodes = {

     

       19
       19
        
               keycloak = { ... }: {

     

       20
       20
       -
                 virtualisation.memorySize = 1024;

     

       21
       20
        
       

     

       22
       21
        
                 security.pki.certificateFiles = [

     

       23
       22
        
                   certs.ca.cert

-2

nixos/tests/lxd-image.nix

···

       46
       46
        
       

     

       47
       47
        
         machine = { lib, ... }: {

     

       48
       48
        
           virtualisation = {

     

       49
       49
       -
             # OOMs otherwise

     

       50
       50
       -
             memorySize = 1024;

     

       51
       49
        
             # disk full otherwise

     

       52
       50
        
             diskSize = 2048;

     

       53
       51

-1

nixos/tests/metabase.nix

···

       7
       7
        
         nodes = {

     

       8
       8
        
           machine = { ... }: {

     

       9
       9
        
             services.metabase.enable = true;

     

       10
       10
       -
             virtualisation.memorySize = 1024;

     

       11
       10
        
           };

     

       12
       11
        
         };

     

       13
       12

-4

nixos/tests/mysql/mysql.nix

···

       64
       64
        
             {

     

       65
       65
        
               imports = [ users ];

     

       66
       66
        
       

     

       67
       67
       -
               # prevent oom:

     

       68
       68
       -
               # Kernel panic - not syncing: Out of memory: compulsory panic_on_oom is enabled

     

       69
       69
       -
               virtualisation.memorySize = 1024;

     

       70
       70
       -
       

     

       71
       67
        
               services.mysql.enable = true;

     

       72
       68
        
               services.mysql.initialDatabases = [

     

       73
       69
        
                 { name = "testdb3"; schema = ./testdb.sql; }

-1

nixos/tests/networking-proxy.nix

···

       8
       8
        
       

     

       9
       9
        
               services.xserver.enable = false;

     

       10
       10
        
       

     

       11
       11
       -
               virtualisation.memorySize = 128;

     

       12
       11
        
             };

     

       13
       12
        
       in import ./make-test-python.nix ({ pkgs, ...} : {

     

       14
       13
        
         name = "networking-proxy";

-1

nixos/tests/nginx-etag.nix

···

       37
       37
        
           };

     

       38
       38
        
       

     

       39
       39
        
           client = { pkgs, lib, ... }: {

     

       40
       40
       -
             virtualisation.memorySize = 512;

     

       41
       40
        
             environment.systemPackages = let

     

       42
       41
        
               testRunner = pkgs.writers.writePython3Bin "test-runner" {

     

       43
       42
        
                 libraries = [ pkgs.python3Packages.selenium ];

-1

nixos/tests/nixops/default.nix

···

       26
       26
        
               nix.binaryCaches = lib.mkForce [ ];

     

       27
       27
        
               users.users.person.isNormalUser = true;

     

       28
       28
        
               virtualisation.writableStore = true;

     

       29
       29
       -
               virtualisation.memorySize = 1024 /*MiB*/;

     

       30
       29
        
               virtualisation.additionalPaths = [

     

       31
       30
        
                 pkgs.hello

     

       32
       31
        
                 pkgs.figlet

-1

nixos/tests/opensmtpd-rspamd.nix

···

       39
       39
        
       

     

       40
       40
        
           smtp2 = { pkgs, ... }: {

     

       41
       41
        
             imports = [ common/user-account.nix ];

     

       42
       42
       -
             virtualisation.memorySize = 512;

     

       43
       42
        
             networking = {

     

       44
       43
        
               firewall.allowedTCPPorts = [ 25 143 ];

     

       45
       44
        
               useDHCP = false;

-1

nixos/tests/pantheon.nix

···

       15
       15
        
           services.xserver.enable = true;

     

       16
       16
        
           services.xserver.desktopManager.pantheon.enable = true;

     

       17
       17
        
       

     

       18
       18
       -
           virtualisation.memorySize = 1024;

     

       19
       18
        
         };

     

       20
       19
        
       

     

       21
       20
        
         enableOCR = true;

-1

nixos/tests/paperless-ng.nix

···

       8
       8
        
             enable = true;

     

       9
       9
        
             passwordFile = builtins.toFile "password" "admin";

     

       10
       10
        
           };

     

       11
       11
       -
           virtualisation.memorySize = 1024;

     

       12
       11
        
         };

     

       13
       12
        
       

     

       14
       13
        
         testScript = ''

-1

nixos/tests/plasma5-systemd-start.nix

···

       21
       21
        
               user = "alice";

     

       22
       22
        
             };

     

       23
       23
        
           };

     

       24
       24
       -
           virtualisation.memorySize = 1024;

     

       25
       24
        
         };

     

       26
       25
        
       

     

       27
       26
        
         testScript = { nodes, ... }: let

-1

nixos/tests/plasma5.nix

···

       19
       19
        
             user = "alice";

     

       20
       20
        
           };

     

       21
       21
        
           hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       22
       22
       -
           virtualisation.memorySize = 1024;

     

       23
       22
        
         };

     

       24
       23
        
       

     

       25
       24
        
         testScript = { nodes, ... }: let

-1

nixos/tests/pleroma.nix

···

       202
       202
        
             security.pki.certificateFiles = [ "${tls-cert}/cert.pem" ];

     

       203
       203
        
             networking.extraHosts = hosts nodes;

     

       204
       204
        
             networking.firewall.enable = false;

     

       205
       205
       -
             virtualisation.memorySize = 512;

     

       206
       205
        
             environment.systemPackages = with pkgs; [

     

       207
       206
        
               provision-db

     

       208
       207
        
               provision-secrets

-1

nixos/tests/privacyidea.nix

···

       8
       8
        
       

     

       9
       9
        
         machine = { ... }: {

     

       10
       10
        
           virtualisation.cores = 2;

     

       11
       11
       -
           virtualisation.memorySize = 512;

     

       12
       11
        
       

     

       13
       12
        
           services.privacyidea = {

     

       14
       13
        
             enable = true;

-2

nixos/tests/prometheus-exporters.nix

···

       464
       464
        
               extraFlags = [ "--lnd.network=regtest" ];

     

       465
       465
        
             };

     

       466
       466
        
             metricProvider = {

     

       467
       467
       -
               virtualisation.memorySize = 1024;

     

       468
       467
        
               systemd.services.prometheus-lnd-exporter.serviceConfig.RestartSec = 15;

     

       469
       468
        
               systemd.services.prometheus-lnd-exporter.after = [ "lnd.service" ];

     

       470
       469
        
               services.bitcoind.regtest = {

     
···

       953
       952
        
             };

     

       954
       953
        
             metricProvider = {

     

       955
       954
        
               services.rspamd.enable = true;

     

       956
       956
       -
               virtualisation.memorySize = 1024;

     

       957
       955
        
             };

     

       958
       956
        
             exporterTest = ''

     

       959
       957
        
               wait_for_unit("rspamd.service")

-1

nixos/tests/prometheus.nix

···

       188
       188
        
             # Minio requires at least 1GiB of free disk space to run.

     

       189
       189
        
             virtualisation = {

     

       190
       190
        
               diskSize = 2 * 1024;

     

       191
       191
       -
               memorySize = 1024;

     

       192
       191
        
             };

     

       193
       192
        
             networking.firewall.allowedTCPPorts = [ minioPort ];

     

       194
       193

-5

nixos/tests/rspamd.nix

···

       25
       25
        
           machine = {

     

       26
       26
        
             services.rspamd.enable = true;

     

       27
       27
        
             networking.enableIPv6 = enableIPv6;

     

       28
       28
       -
             virtualisation.memorySize = 1024;

     

       29
       28
        
           };

     

       30
       29
        
           testScript = ''

     

       31
       30
        
             start_all()

     
···

       69
       68
        
                 group = "rspamd";

     

       70
       69
        
               }];

     

       71
       70
        
             };

     

       72
       72
       -
             virtualisation.memorySize = 1024;

     

       73
       71
        
           };

     

       74
       72
        
       

     

       75
       73
        
           testScript = ''

     
···

       118
       116
        
                 '';

     

       119
       117
        
               };

     

       120
       118
        
             };

     

       121
       121
       -
             virtualisation.memorySize = 1024;

     

       122
       119
        
           };

     

       123
       120
        
       

     

       124
       121
        
           testScript = ''

     
···

       224
       221
        
                 rspamd_logger.infox(rspamd_config, 'Work dammit!!!')

     

       225
       222
        
               '';

     

       226
       223
        
             };

     

       227
       227
       -
             virtualisation.memorySize = 1024;

     

       228
       224
        
           };

     

       229
       225
        
           testScript = ''

     

       230
       226
        
             ${initMachine}

     
···

       291
       287
        
               postfix.enable = true;

     

       292
       288
        
               workers.rspamd_proxy.type = "rspamd_proxy";

     

       293
       289
        
             };

     

       294
       294
       -
             virtualisation.memorySize = 1024;

     

       295
       290
        
           };

     

       296
       291
        
           testScript = ''

     

       297
       292
        
             ${initMachine}

-2

nixos/tests/seafile.nix

···

       1
       1
        
       import ./make-test-python.nix ({ pkgs, ... }:

     

       2
       2
        
         let

     

       3
       3
        
           client = { config, pkgs, ... }: {

     

       4
       4
       -
             virtualisation.memorySize = 256;

     

       5
       4
        
             environment.systemPackages = [ pkgs.seafile-shared pkgs.curl ];

     

       6
       5
        
           };

     

       7
       6
        
         in {

     
···

       12
       11
        
       

     

       13
       12
        
           nodes = {

     

       14
       13
        
             server = { config, pkgs, ... }: {

     

       15
       15
       -
               virtualisation.memorySize = 512;

     

       16
       14
        
               services.seafile = {

     

       17
       15
        
                 enable = true;

     

       18
       16
        
                 ccnetSettings.General.SERVICE_URL = "http://server";

-1

nixos/tests/signal-desktop.nix

···

       29
       29
        
           environment.systemPackages = with pkgs; [

     

       30
       30
        
             signal-desktop file sqlite sqlcipher-signal

     

       31
       31
        
           ];

     

       32
       32
       -
           virtualisation.memorySize = 1024;

     

       33
       32
        
         };

     

       34
       33
        
       

     

       35
       34
        
         enableOCR = true;

-1

nixos/tests/spark/default.nix

···

       3
       3
        
       

     

       4
       4
        
         nodes = {

     

       5
       5
        
           worker = { nodes, pkgs, ... }: {

     

       6
       6
       -
             virtualisation.memorySize = 1024;

     

       7
       6
        
             services.spark.worker = {

     

       8
       7
        
               enable = true;

     

       9
       8
        
               master = "master:7077";

-1

nixos/tests/sway.nix

···

       44
       44
        
           # To test pinentry via gpg-agent:

     

       45
       45
        
           programs.gnupg.agent.enable = true;

     

       46
       46
        
       

     

       47
       47
       -
           virtualisation.memorySize = 1024;

     

       48
       47
        
           # Need to switch to a different GPU driver than the default one (-vga std) so that Sway can launch:

     

       49
       48
        
           virtualisation.qemu.options = [ "-vga none -device virtio-gpu-pci" ];

     

       50
       49
        
         };

-1

nixos/tests/sympa.nix

···

       5
       5
        
         machine =

     

       6
       6
        
           { ... }:

     

       7
       7
        
           {

     

       8
       8
       -
             virtualisation.memorySize = 1024;

     

       9
       8
        
       

     

       10
       9
        
             services.sympa = {

     

       11
       10
        
               enable = true;

-1

nixos/tests/systemd-cryptenroll.nix

···

       8
       8
        
           environment.systemPackages = [ pkgs.cryptsetup ];

     

       9
       9
        
           virtualisation = {

     

       10
       10
        
             emptyDiskImages = [ 512 ];

     

       11
       11
       -
             memorySize = 1024;

     

       12
       11
        
             qemu.options = [

     

       13
       12
        
               "-chardev socket,id=chrtpm,path=/tmp/swtpm-sock"

     

       14
       13
        
               "-tpmdev emulator,id=tpm0,chardev=chrtpm"

-1

nixos/tests/systemd.nix

···

       5
       5
        
           imports = [ common/user-account.nix common/x11.nix ];

     

       6
       6
        
       

     

       7
       7
        
           virtualisation.emptyDiskImages = [ 512 512 ];

     

       8
       8
       -
           virtualisation.memorySize = 1024;

     

       9
       8
        
       

     

       10
       9
        
           environment.systemPackages = [ pkgs.cryptsetup ];

     

       11
       10

-1

nixos/tests/vault-postgresql.nix

···

       12
       12
        
           maintainers = [ lnl7 roberth ];

     

       13
       13
        
         };

     

       14
       14
        
         machine = { lib, pkgs, ... }: {

     

       15
       15
       -
           virtualisation.memorySize = 512;

     

       16
       15
        
           environment.systemPackages = [ pkgs.vault ];

     

       17
       16
        
           environment.variables.VAULT_ADDR = "http://127.0.0.1:8200";

     

       18
       17
        
           services.vault.enable = true;

-1

nixos/tests/vault.nix

···

       8
       8
        
           environment.systemPackages = [ pkgs.vault ];

     

       9
       9
        
           environment.variables.VAULT_ADDR = "http://127.0.0.1:8200";

     

       10
       10
        
           services.vault.enable = true;

     

       11
       11
       -
           virtualisation.memorySize = 512;

     

       12
       11
        
         };

     

       13
       12
        
       

     

       14
       13
        
         testScript =

-1

nixos/tests/vaultwarden.nix

···

       140
       140
        
                     in

     

       141
       141
        
                     [ pkgs.firefox-unwrapped pkgs.geckodriver testRunner ];

     

       142
       142
        
       

     

       143
       143
       -
                   virtualisation.memorySize = 768;

     

       144
       143
        
                 }

     

       145
       144
        
               ];

     

       146
       145

-1

nixos/tests/xfce.nix

···

       23
       23
        
       

     

       24
       24
        
             hardware.pulseaudio.enable = true; # needed for the factl test, /dev/snd/* exists without them but udev doesn't care then

     

       25
       25
        
       

     

       26
       26
       -
             virtualisation.memorySize = 1024;

     

       27
       26
        
           };

     

       28
       27
        
       

     

       29
       28
        
         testScript = { nodes, ... }: let

+1 -1

pkgs/applications/graphics/krita/generic.nix

···

       32
       32
        
           openjpeg opencolorio_1 poppler curl ilmbase

     

       33
       33
        
           qtmultimedia qtx11extras quazip

     

       34
       34
        
           python3Packages.pyqt5

     

       35
       35
       -
         ] ++ lib.optional (stdenv.hostPlatform.isi686 || stdenv.hostPlatform.isx86_64) vc;

     

       35
       35
       +
         ] ++ lib.optional stdenv.hostPlatform.isx86 vc;

     

       36
       36
        
       

     

       37
       37
        
         NIX_CFLAGS_COMPILE = [ "-I${ilmbase.dev}/include/OpenEXR" ]

     

       38
       38
        
           ++ lib.optional stdenv.cc.isGNU "-Wno-deprecated-copy";

+7 -5

pkgs/applications/graphics/qvge/default.nix

···

       1
       1
        
       { lib

     

       2
       2
       -
       , mkDerivation

     

       2
       2
       +
       , stdenv

     

       3
       3
        
       , fetchFromGitHub

     

       4
       4
        
       , substituteAll

     

       5
       5
       +
       , wrapQtAppsHook

     

       5
       6
        
       , qmake

     

       7
       7
       +
       , qtsvg

     

       6
       8
        
       , qtx11extras

     

       7
       9
        
       , graphviz

     

       8
       10
        
       }:

     

       9
       11
        
       

     

       10
       10
       -
       mkDerivation rec {

     

       12
       12
       +
       stdenv.mkDerivation rec {

     

       11
       13
        
         pname = "qvge";

     

       12
       14
        
         version = "0.6.3";

     

       13
       15
        
       

     
···

       25
       27
        
           inherit graphviz;

     

       26
       28
        
         });

     

       27
       29
        
       

     

       28
       28
       -
         nativeBuildInputs = [ qmake ];

     

       30
       30
       +
         nativeBuildInputs = [ wrapQtAppsHook qmake ];

     

       29
       31
        
       

     

       30
       30
       -
         buildInputs = [ qtx11extras ];

     

       32
       32
       +
         buildInputs = if stdenv.isDarwin then [ qtsvg ] else [ qtx11extras ];

     

       31
       33
        
       

     

       32
       34
        
         meta = with lib; {

     

       33
       35
        
           description = "Qt Visual Graph Editor";

     

       34
       36
        
           homepage = "https://github.com/ArsMasiuk/qvge";

     

       35
       37
        
           license = licenses.mit;

     

       36
       38
        
           maintainers = with maintainers; [ sikmir ];

     

       37
       37
       -
           platforms = with platforms; linux;

     

       39
       39
       +
           platforms = platforms.unix;

     

       38
       40
        
         };

     

       39
       41
        
       }

+59 -24

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

···

       27
       27
        
       , ltoSupport ? (stdenv.isLinux && stdenv.is64bit), overrideCC, buildPackages

     

       28
       28
        
       , gssSupport ? true, libkrb5

     

       29
       29
        
       , pipewireSupport ? waylandSupport && webrtcSupport, pipewire

     

       30
       30
       -
       , jemallocSupport ? true, jemalloc

     

       30
       30
       +
       # Workaround: disabled since currently jemalloc causes crashes with LLVM 13.

     

       31
       31
       +
       # https://bugzilla.mozilla.org/show_bug.cgi?id=1741454

     

       32
       32
       +
       , jemallocSupport ? false, jemalloc

     

       31
       33
        
       

     

       32
       34
        
       ## privacy-related options

     

       33
       35
        
       

     
···

       71
       73
        
       # > the experience of Firefox users, you won't have any issues using the

     

       72
       74
        
       # > official branding.

     

       73
       75
        
       , enableOfficialBranding ? true

     

       76
       76
       +
       

     

       77
       77
       +
       # On 32bit platforms, we disable adding "-g" for easier linking.

     

       78
       78
       +
       , enableDebugSymbols ? !stdenv.is32bit

     

       74
       79
        
       }:

     

       75
       80
        
       

     

       76
       81
        
       assert stdenv.cc.libc or null != null;

     
···

       116
       121
        
                       })

     

       117
       122
        
                       else stdenv;

     

       118
       123
        
       

     

       119
       119
       -
         # --enable-release adds -ffunction-sections & LTO that require a big amount of

     

       120
       120
       -
         # RAM and the 32-bit memory space cannot handle that linking

     

       121
       121
       -
         # We also disable adding "-g" for easier linking

     

       122
       122
       -
         releaseFlags = if stdenv.is32bit

     

       123
       123
       -
                        then [ "--disable-release" "--disable-debug-symbols" ]

     

       124
       124
       -
                        else [ "--enable-release" ];

     

       125
       124
        
       in

     

       126
       125
        
       

     

       127
       126
        
       buildStdenv.mkDerivation ({

     
···

       174
       173
        
                                                 AVFoundation MediaToolbox CoreLocation

     

       175
       174
        
                                                 Foundation libobjc AddressBook cups ];

     

       176
       175
        
       

     

       177
       177
       -
         NIX_LDFLAGS = lib.optionalString ltoSupport ''

     

       178
       178
       -
           -rpath ${llvmPackages.libunwind.out}/lib

     

       179
       179
       -
         '';

     

       180
       180
       -
       

     

       181
       176
        
         MACH_USE_SYSTEM_PYTHON = "1";

     

       182
       177
        
       

     

       183
       178
        
         postPatch = ''

     
···

       206
       201
        
           ++ lib.optionals buildStdenv.isDarwin [ xcbuild rsync ]

     

       207
       202
        
           ++ extraNativeBuildInputs;

     

       208
       203
        
       

     

       204
       204
       +
         separateDebugInfo = enableDebugSymbols;

     

       205
       205
       +
         setOutputFlags = false; # `./mach configure` doesn't understand `--*dir=` flags.

     

       206
       206
       +
       

     

       209
       207
        
         preConfigure = ''

     

       210
       208
        
           # remove distributed configuration files

     

       211
       209
        
           rm -f configure

     
···

       229
       227
        
             ${lib.optionalString buildStdenv.cc.isClang "-idirafter ${buildStdenv.cc.cc.lib}/lib/clang/${lib.getVersion buildStdenv.cc.cc}/include"} \

     

       230
       228
        
             ${lib.optionalString buildStdenv.cc.isGNU "-isystem ${lib.getDev buildStdenv.cc.cc}/include/c++/${lib.getVersion buildStdenv.cc.cc} -isystem ${buildStdenv.cc.cc}/include/c++/${lib.getVersion buildStdenv.cc.cc}/${buildStdenv.hostPlatform.config}"} \

     

       231
       229
        
             $NIX_CFLAGS_COMPILE"

     

       232
       232
       -
       

     

       230
       230
       +
           ${

     

       231
       231
       +
           # Bindgen doesn't like the flag added by `separateDebugInfo`.

     

       232
       232
       +
           lib.optionalString enableDebugSymbols ''

     

       233
       233
       +
             BINDGEN_CFLAGS="''${BINDGEN_CFLAGS/ -Wa,--compress-debug-sections/}"

     

       234
       234
       +
           ''}

     

       233
       235
        
           echo "ac_add_options BINDGEN_CFLAGS='$BINDGEN_CFLAGS'" >> $MOZCONFIG

     

       234
       236
        
         '' + (lib.optionalString googleAPISupport ''

     

       235
       237
        
           # Google API key used by Chromium and Firefox.

     
···

       273
       275
        
         #   https://bugzilla.mozilla.org/show_bug.cgi?id=1538724

     

       274
       276
        
         # elf-hack is broken when using clang+lld:

     

       275
       277
        
         #   https://bugzilla.mozilla.org/show_bug.cgi?id=1482204

     

       276
       276
       -
         ++ lib.optional ltoSupport "--enable-lto"

     

       278
       278
       +
         ++ lib.optional ltoSupport "--enable-lto=cross" # Cross-language LTO.

     

       277
       279
        
         ++ lib.optional (ltoSupport && (buildStdenv.isAarch32 || buildStdenv.isi686 || buildStdenv.isx86_64)) "--disable-elf-hack"

     

       278
       280
        
         ++ lib.optional (ltoSupport && !buildStdenv.isDarwin) "--enable-linker=lld"

     

       279
       281
        
       

     
···

       287
       289
        
         ++ lib.optional drmSupport "--enable-eme=widevine"

     

       288
       290
        
       

     

       289
       291
        
         ++ (if debugBuild then [ "--enable-debug" "--enable-profiling" ]

     

       290
       290
       -
                           else ([ "--disable-debug"

     

       291
       291
       -
                                  "--enable-optimize"

     

       292
       292
       -
                                  "--enable-strip" ] ++ releaseFlags))

     

       292
       292
       +
                           else [ "--disable-debug" "--enable-optimize" ])

     

       293
       293
       +
         # --enable-release adds -ffunction-sections & LTO that require a big amount of

     

       294
       294
       +
         # RAM and the 32-bit memory space cannot handle that linking

     

       295
       295
       +
         ++ flag (!debugBuild && !stdenv.is32bit) "release"

     

       296
       296
       +
         ++ flag enableDebugSymbols "debug-symbols"

     

       297
       297
       +
         ++ lib.optionals enableDebugSymbols [ "--disable-strip" "--disable-install-strip" ]

     

       298
       298
       +
       

     

       293
       299
        
         ++ lib.optional enableOfficialBranding "--enable-official-branding"

     

       294
       300
        
         ++ extraConfigureFlags;

     

       295
       301
        
       

     
···

       297
       303
        
           cd obj-*

     

       298
       304
        
         '';

     

       299
       305
        
       

     

       300
       300
       -
         makeFlags = lib.optionals ltoSupport [

     

       301
       301
       -
           "AR=${buildStdenv.cc.bintools.bintools}/bin/llvm-ar"

     

       302
       302
       -
           "LLVM_OBJDUMP=${buildStdenv.cc.bintools.bintools}/bin/llvm-objdump"

     

       303
       303
       -
           "NM=${buildStdenv.cc.bintools.bintools}/bin/llvm-nm"

     

       304
       304
       -
           "RANLIB=${buildStdenv.cc.bintools.bintools}/bin/llvm-ranlib"

     

       305
       305
       -
           "STRIP=${buildStdenv.cc.bintools.bintools}/bin/llvm-strip"

     

       306
       306
       -
         ]

     

       307
       307
       -
         ++ extraMakeFlags;

     

       306
       306
       +
         makeFlags = extraMakeFlags;

     

       308
       307
        
       

     

       309
       308
        
         enableParallelBuilding = true;

     

       310
       309
        
         doCheck = false; # "--disable-tests" above

     
···

       320
       319
        
       

     

       321
       320
        
           # Needed to find Mozilla runtime

     

       322
       321
        
           gappsWrapperArgs+=(--argv0 "$out/bin/.${binaryName}-wrapped")

     

       322
       322
       +
         '';

     

       323
       323
       +
       

     

       324
       324
       +
         # Workaround: The separateDebugInfo hook skips artifacts whose build ID's length is not 40.

     

       325
       325
       +
         # But we got 16-length build ID here. The function body is mainly copied from pkgs/build-support/setup-hooks/separate-debug-info.sh

     

       326
       326
       +
         # Remove it when PR #146275 is merged.

     

       327
       327
       +
         preFixup = lib.optionalString enableDebugSymbols ''

     

       328
       328
       +
           _separateDebugInfo() {

     

       329
       329
       +
               [ -e "$prefix" ] || return 0

     

       330
       330
       +
       

     

       331
       331
       +
               local dst="''${debug:-$out}"

     

       332
       332
       +
               if [ "$prefix" = "$dst" ]; then return 0; fi

     

       333
       333
       +
       

     

       334
       334
       +
               dst="$dst/lib/debug/.build-id"

     

       335
       335
       +
       

     

       336
       336
       +
               # Find executables and dynamic libraries.

     

       337
       337
       +
               local i

     

       338
       338
       +
               while IFS= read -r -d $'\0' i; do

     

       339
       339
       +
                   if ! isELF "$i"; then continue; fi

     

       340
       340
       +
       

     

       341
       341
       +
                   # Extract the Build ID. FIXME: there's probably a cleaner way.

     

       342
       342
       +
                   local id="$($READELF -n "$i" | sed 's/.*Build ID: \([0-9a-f]*\).*/\1/; t; d')"

     

       343
       343
       +
                   if [[ -z "$id" ]]; then

     

       344
       344
       +
                       echo "could not find build ID of $i, skipping" >&2

     

       345
       345
       +
                       continue

     

       346
       346
       +
                   fi

     

       347
       347
       +
       

     

       348
       348
       +
                   # Extract the debug info.

     

       349
       349
       +
                   header "separating debug info from $i (build ID $id)"

     

       350
       350
       +
                   mkdir -p "$dst/''${id:0:2}"

     

       351
       351
       +
                   $OBJCOPY --only-keep-debug "$i" "$dst/''${id:0:2}/''${id:2}.debug"

     

       352
       352
       +
                   $STRIP --strip-debug "$i"

     

       353
       353
       +
       

     

       354
       354
       +
                   # Also a create a symlink <original-name>.debug.

     

       355
       355
       +
                   ln -sfn ".build-id/''${id:0:2}/''${id:2}.debug" "$dst/../$(basename "$i")"

     

       356
       356
       +
               done < <(find "$prefix" -type f -print0)

     

       357
       357
       +
           }

     

       323
       358
        
         '';

     

       324
       359
        
       

     

       325
       360
        
         doInstallCheck = true;

+2 -1

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

···

       20
       20
        
           homepage = "http://hmmer.org/";

     

       21
       21
        
           license = licenses.gpl3;

     

       22
       22
        
           maintainers = [ maintainers.iimog ];

     

       23
       23
       -
           platforms = platforms.unix;

     

       23
       23
       +
           # at least SSE is *required*

     

       24
       24
       +
           platforms = platforms.x86_64;

     

       24
       25
        
         };

     

       25
       26
        
       }

+1 -1

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

···

       31
       31
        
         # source behind __linux__ check assumes system is also x86 and

     

       32
       32
        
         # tries to disable x86/x87-specific extended precision mode

     

       33
       33
        
         # https://github.com/sambayless/monosat/issues/33

     

       34
       34
       -
         commonPostPatch = lib.optionalString (!(stdenv.isi686 || stdenv.isx86_64)) ''

     

       34
       34
       +
         commonPostPatch = lib.optionalString (!stdenv.hostPlatform.isx86) ''

     

       35
       35
        
           substituteInPlace src/monosat/Main.cc \

     

       36
       36
        
             --replace 'defined(__linux__)' '0'

     

       37
       37
        
         '';

+1 -1

pkgs/applications/video/mplayer/default.nix

···

       174
       174
        
                (useUnfreeCodecs && codecs != null && !crossBuild)

     

       175
       175
        
                "--codecsdir=${codecs}"

     

       176
       176
        
           ++ optional

     

       177
       177
       -
                ((stdenv.hostPlatform.isi686 || stdenv.hostPlatform.isx86_64) && !crossBuild)

     

       177
       177
       +
                (stdenv.hostPlatform.isx86 && !crossBuild)

     

       178
       178
        
                "--enable-runtime-cpudetection"

     

       179
       179
        
           ++ optional fribidiSupport "--enable-fribidi"

     

       180
       180
        
           ++ optional stdenv.isLinux "--enable-vidix"

+4

pkgs/build-support/fetchurl/mirrors.nix

···

       151
       151
        
         cpan = [

     

       152
       152
        
           "https://cpan.metacpan.org/"

     

       153
       153
        
           "https://cpan.perl.org/"

     

       154
       154
       +
           "https://mirrors.kernel.org/CPAN/"

     

       154
       155
        
           "https://backpan.perl.org/"  # for old releases

     

       155
       156
        
         ];

     

       156
       157
        
       

     
···

       171
       172
        
         debian = [

     

       172
       173
        
           "https://httpredir.debian.org/debian/"

     

       173
       174
        
           "https://ftp.debian.org/debian/"

     

       175
       175
       +
           "https://mirrors.edge.kernel.org/debian/"

     

       174
       176
        
           "ftp://ftp.de.debian.org/debian/"

     

       175
       177
        
           "ftp://ftp.fr.debian.org/debian/"

     

       176
       178
        
           "ftp://ftp.nl.debian.org/debian/"

     
···

       183
       185
        
         ubuntu = [

     

       184
       186
        
           "https://nl.archive.ubuntu.com/ubuntu/"

     

       185
       187
        
           "https://old-releases.ubuntu.com/ubuntu/"

     

       188
       188
       +
           "https://mirrors.edge.kernel.org/ubuntu/"

     

       186
       189
        
           "http://de.archive.ubuntu.com/ubuntu/"

     

       187
       190
        
           "http://archive.ubuntu.com/ubuntu/"

     

       188
       191
        
         ];

     
···

       206
       209
        
           "https://ftp.funet.fi/pub/linux/mirrors/opensuse/distribution/"

     

       207
       210
        
           "https://ftp.opensuse.org/pub/opensuse/distribution/"

     

       208
       211
        
           "https://ftp5.gwdg.de/pub/opensuse/discontinued/distribution/"

     

       212
       212
       +
           "https://mirrors.edge.kernel.org/opensuse/distribution/"

     

       209
       213
        
           "http://ftp.hosteurope.de/mirror/ftp.opensuse.org/discontinued/"

     

       210
       214
        
         ];

     

       211
       215

+1 -1

pkgs/build-support/trivial-builders.nix

···

       749
       749
        
           { package,

     

       750
       750
        
             command ? "${package.meta.mainProgram or package.pname or package.name} --version",

     

       751
       751
        
             version ? package.version,

     

       752
       752
       -
           }: runCommand "test-version" { nativeBuildInputs = [ package ]; meta.timeout = 60; } ''

     

       752
       752
       +
           }: runCommand "${package.name}-test-version" { nativeBuildInputs = [ package ]; meta.timeout = 60; } ''

     

       753
       753
        
             ${command} |& grep -Fw ${version}

     

       754
       754
        
             touch $out

     

       755
       755
        
           '';

+1 -1

pkgs/build-support/vm/default.nix

···

       5
       5
        
       , storeDir ? builtins.storeDir

     

       6
       6
        
       , rootModules ?

     

       7
       7
        
           [ "virtio_pci" "virtio_mmio" "virtio_blk" "virtio_balloon" "virtio_rng" "ext4" "unix" "9p" "9pnet_virtio" "crc32c_generic" ]

     

       8
       8
       -
             ++ pkgs.lib.optional (pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) "rtc_cmos"

     

       8
       8
       +
             ++ pkgs.lib.optional pkgs.stdenv.hostPlatform.isx86 "rtc_cmos"

     

       9
       9
        
       }:

     

       10
       10
        
       

     

       11
       11
        
       let

+1 -1

pkgs/desktops/gnome/core/gnome-software/default.nix

···

       37
       37
        
       }:

     

       38
       38
        
       

     

       39
       39
        
       let

     

       40
       40
       -
         withFwupd = stdenv.isx86_64 || stdenv.isi686;

     

       40
       40
       +
         withFwupd = stdenv.hostPlatform.isx86;

     

       41
       41
        
       in

     

       42
       42
        
       

     

       43
       43
        
       stdenv.mkDerivation rec {

+1 -1

pkgs/development/compilers/ocaml/ber-metaocaml.nix

···

       4
       4
        
       }:

     

       5
       5
        
       

     

       6
       6
        
       let

     

       7
       7
       -
          useX11 = stdenv.isi686 || stdenv.isx86_64;

     

       7
       7
       +
          useX11 = stdenv.hostPlatform.isx86;

     

       8
       8
        
          x11deps = [ libX11 xorgproto ];

     

       9
       9
        
          inherit (lib) optionals;

     

       10
       10

+2 -2

pkgs/development/compilers/sbcl/common.nix

···

       2
       2
        
       

     

       3
       3
        
       { lib, stdenv, fetchurl, fetchpatch, writeText, sbclBootstrap

     

       4
       4
        
       , sbclBootstrapHost ? "${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit"

     

       5
       5
       -
       , threadSupport ? (stdenv.isi686 || stdenv.isx86_64 || "aarch64-linux" == stdenv.hostPlatform.system || "aarch64-darwin" == stdenv.hostPlatform.system)

     

       6
       6
       -
       , linkableRuntime ? (stdenv.isi686 || stdenv.isx86_64)

     

       5
       5
       +
       , threadSupport ? (stdenv.hostPlatform.isx86 || "aarch64-linux" == stdenv.hostPlatform.system || "aarch64-darwin" == stdenv.hostPlatform.system)

     

       6
       6
       +
       , linkableRuntime ? stdenv.hostPlatform.isx86

     

       7
       7
        
       , disableImmobileSpace ? false

     

       8
       8
        
         # Meant for sbcl used for creating binaries portable to non-NixOS via save-lisp-and-die.

     

       9
       9
        
         # Note that the created binaries still need `patchelf --set-interpreter ...`

+2 -2

pkgs/development/interpreters/clisp/default.nix

···

       9
       9
        
       , libffcall

     

       10
       10
        
       , coreutils

     

       11
       11
        
       # build options

     

       12
       12
       -
       , threadSupport ? (stdenv.isi686 || stdenv.isx86_64)

     

       13
       13
       -
       , x11Support ? (stdenv.isi686 || stdenv.isx86_64)

     

       12
       12
       +
       , threadSupport ? stdenv.hostPlatform.isx86

     

       13
       13
       +
       , x11Support ? stdenv.hostPlatform.isx86

     

       14
       14
        
       , dllSupport ? true

     

       15
       15
        
       , withModules ? [

     

       16
       16
        
           "pcre"

+2 -2

pkgs/development/interpreters/clisp/hg.nix

···

       8
       8
        
       , libffi, libffcall, automake

     

       9
       9
        
       , coreutils

     

       10
       10
        
       # build options

     

       11
       11
       -
       , threadSupport ? (stdenv.isi686 || stdenv.isx86_64)

     

       12
       12
       -
       , x11Support ? (stdenv.isi686 || stdenv.isx86_64)

     

       11
       11
       +
       , threadSupport ? stdenv.hostPlatform.isx86

     

       12
       12
       +
       , x11Support ? stdenv.hostPlatform.isx86

     

       13
       13
        
       , dllSupport ? true

     

       14
       14
        
       , withModules ? [

     

       15
       15
        
           "pcre"

+1 -1

pkgs/development/libraries/SDL2_gfx/default.nix

···

       14
       14
        
         buildInputs = [ SDL2 ]

     

       15
       15
        
           ++ lib.optional stdenv.isDarwin darwin.libobjc;

     

       16
       16
        
       

     

       17
       17
       -
         configureFlags = [(if stdenv.isi686 || stdenv.isx86_64 then "--enable-mmx" else "--disable-mmx")]

     

       17
       17
       +
         configureFlags = [(if stdenv.hostPlatform.isx86 then "--enable-mmx" else "--disable-mmx")]

     

       18
       18
        
            ++ lib.optional stdenv.isDarwin "--disable-sdltest";

     

       19
       19
        
       

     

       20
       20
        
         meta = with lib; {

+1 -1

pkgs/development/libraries/glibc/common.nix

···

       161
       161
        
             "--enable-bind-now"

     

       162
       162
        
             (lib.withFeatureAs withLinuxHeaders "headers" "${linuxHeaders}/include")

     

       163
       163
        
             (lib.enableFeature profilingLibraries "profile")

     

       164
       164
       -
           ] ++ lib.optionals (stdenv.hostPlatform.isx86_64 || stdenv.hostPlatform.isi686 || stdenv.hostPlatform.isAarch64) [

     

       164
       164
       +
           ] ++ lib.optionals (stdenv.hostPlatform.isx86 || stdenv.hostPlatform.isAarch64) [

     

       165
       165
        
             # This feature is currently supported on

     

       166
       166
        
             # i386, x86_64 and x32 with binutils 2.29 or later,

     

       167
       167
        
             # and on aarch64 with binutils 2.30 or later.

+14 -5

pkgs/development/libraries/libgphoto2/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchFromGitHub, autoreconfHook, pkg-config, gettext

     

       1
       1
       +
       { lib, stdenv, fetchFromGitHub, buildPackages

     

       2
       2
       +
       , autoreconfHook, pkg-config, gettext

     

       2
       3
        
       , libusb1

     

       3
       4
        
       , libtool

     

       4
       5
        
       , libexif

     

       6
       6
       +
       , libgphoto2

     

       5
       7
        
       , libjpeg

     

       6
       8
        
       }:

     

       7
       9
        
       

     
···

       16
       18
        
           sha256 = "sha256-c7fBl6GBLAU+RL5WFC4PL+n/nEHZUfqIJ9qq1+qNNCg=";

     

       17
       19
        
         };

     

       18
       20
        
       

     

       19
       19
       -
         patches = [];

     

       21
       21
       +
         depsBuildBuild = [ pkg-config ];

     

       20
       22
        
       

     

       21
       23
        
         nativeBuildInputs = [

     

       22
       24
        
           autoreconfHook

     

       23
       23
       -
           pkg-config

     

       24
       25
        
           gettext

     

       25
       26
        
           libtool

     

       26
       27
        
         ];

     

       27
       28
        
       

     

       28
       29
        
         buildInputs = [

     

       29
       30
        
           libjpeg

     

       31
       31
       +
           libtool # for libltdl

     

       30
       32
        
           libusb1

     

       31
       33
        
         ];

     

       32
       34
        
       

     
···

       35
       37
        
       

     

       36
       38
        
         hardeningDisable = [ "format" ];

     

       37
       39
        
       

     

       38
       38
       -
         postInstall = ''

     

       40
       40
       +
         postInstall = let

     

       41
       41
       +
           executablePrefix = if stdenv.buildPlatform == stdenv.hostPlatform then

     

       42
       42
       +
             "$out"

     

       43
       43
       +
           else

     

       44
       44
       +
             buildPackages.libgphoto2;

     

       45
       45
       +
         in ''

     

       39
       46
        
           mkdir -p $out/lib/udev/rules.d

     

       40
       40
       -
           $out/lib/libgphoto2/print-camera-list udev-rules version 175 group camera >$out/lib/udev/rules.d/40-gphoto2.rules

     

       47
       47
       +
           ${executablePrefix}/lib/libgphoto2/print-camera-list \

     

       48
       48
       +
               udev-rules version 175 group camera \

     

       49
       49
       +
               >$out/lib/udev/rules.d/40-gphoto2.rules

     

       41
       50
        
         '';

     

       42
       51
        
       

     

       43
       52
        
         meta = {

+1 -1

pkgs/development/libraries/libimagequant/default.nix

···

       15
       15
        
           patchShebangs ./configure

     

       16
       16
        
         '';

     

       17
       17
        
       

     

       18
       18
       -
         configureFlags = lib.optionals (!stdenv.isi686 && !stdenv.isx86_64) [ "--disable-sse" ];

     

       18
       18
       +
         configureFlags = lib.optionals (!stdenv.hostPlatform.isx86) [ "--disable-sse" ];

     

       19
       19
        
       

     

       20
       20
        
         meta = with lib; {

     

       21
       21
        
           homepage = "https://pngquant.org/lib/";

+2 -2

pkgs/development/libraries/libite/default.nix

···

       15
       15
        
         buildInputs = [ libconfuse ];

     

       16
       16
        
       

     

       17
       17
        
         meta = with lib; {

     

       18
       18
       -
           inherit (src.meta) homepage;

     

       19
       18
        
           description = "Lightweight library of frog DNA";

     

       20
       19
        
           longDescription = ''

     

       21
       20
        
             Libite is a lightweight library of frog DNA. It can be used to fill

     
···

       29
       28
        
             _SAFE macros in the BSD sys/queue.h API — highly recommended when

     

       30
       29
        
             traversing lists to delete/free nodes.

     

       31
       30
        
           '';

     

       32
       32
       -
           platforms = platforms.unix;

     

       31
       31
       +
           homepage = "https://github.com/troglobit/libite";

     

       32
       32
       +
           platforms = with platforms; linux ++ netbsd;

     

       33
       33
        
           maintainers = with maintainers; [ fpletz ];

     

       34
       34
        
           license = with licenses; [ mit isc bsd2 bsd3 ];

     

       35
       35
        
         };

+1 -1

pkgs/development/libraries/libtsm/default.nix

···

       20
       20
        
           homepage = "http://www.freedesktop.org/wiki/Software/kmscon/libtsm/";

     

       21
       21
        
           license = licenses.mit;

     

       22
       22
        
           maintainers = with maintainers; [ cstrahan ];

     

       23
       23
       -
           platforms = with platforms; unix;

     

       23
       23
       +
           platforms = platforms.linux;

     

       24
       24
        
         };

     

       25
       25
        
       }

+1 -1

pkgs/development/libraries/opencolorio/1.x.nix

···

       29
       29
        
           # External libyamlcpp 0.6.* not compatible: https://github.com/imageworks/OpenColorIO/issues/517

     

       30
       30
        
           "-DUSE_EXTERNAL_YAML=OFF"

     

       31
       31
        
         ] ++ lib.optional stdenv.isDarwin "-DOCIO_USE_BOOST_PTR=ON"

     

       32
       32
       -
           ++ lib.optional (!stdenv.hostPlatform.isi686 && !stdenv.hostPlatform.isx86_64) "-DOCIO_USE_SSE=OFF";

     

       32
       32
       +
           ++ lib.optional (!stdenv.hostPlatform.isx86) "-DOCIO_USE_SSE=OFF";

     

       33
       33
        
       

     

       34
       34
        
         postInstall = ''

     

       35
       35
        
           mkdir -p $bin/bin; mv $out/bin $bin/

+1 -1

pkgs/development/libraries/pcl/default.nix

···

       34
       34
        
       

     

       35
       35
        
         # remove attempt to prevent (x86/x87-specific) extended precision use

     

       36
       36
        
         # when SSE not detected

     

       37
       37
       -
         postPatch = lib.optionalString (!(stdenv.isi686 || stdenv.isx86_64)) ''

     

       37
       37
       +
         postPatch = lib.optionalString (!stdenv.hostPlatform.isx86) ''

     

       38
       38
        
           sed -i '/-ffloat-store/d' cmake/pcl_find_sse.cmake

     

       39
       39
        
         '';

     

       40
       40

+1 -1

pkgs/development/libraries/x264/default.nix

···

       37
       37
        
           ++ lib.optional (!stdenv.isi686) "--enable-pic"

     

       38
       38
        
           ++ lib.optional (stdenv.buildPlatform != stdenv.hostPlatform) "--cross-prefix=${stdenv.cc.targetPrefix}";

     

       39
       39
        
       

     

       40
       40
       -
         nativeBuildInputs = lib.optional (stdenv.hostPlatform.isx86_64 || stdenv.hostPlatform.isi686) nasm;

     

       40
       40
       +
         nativeBuildInputs = lib.optional stdenv.hostPlatform.isx86 nasm;

     

       41
       41
        
       

     

       42
       42
        
         meta = with lib; {

     

       43
       43
        
           description = "Library for encoding H264/AVC video streams";

+2 -2

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

···

       9
       9
        
       

     

       10
       10
        
       buildPythonPackage rec {

     

       11
       11
        
         pname = "casbin";

     

       12
       12
       -
         version = "1.9.7";

     

       12
       12
       +
         version = "1.11.1";

     

       13
       13
        
         format = "setuptools";

     

       14
       14
        
       

     

       15
       15
        
         disabled = pythonOlder "3.6";

     
···

       18
       18
        
           owner = pname;

     

       19
       19
        
           repo = "pycasbin";

     

       20
       20
        
           rev = "v${version}";

     

       21
       21
       -
           sha256 = "sha256-wNygKs37PtMLij3f+pAh6PNLqQ45cvrpF43Aj+cO8p8=";

     

       21
       21
       +
           sha256 = "sha256-gFGYpHd1kp4JMtoe47VbJ0uDnuGQegggbjXaw6nEMR4=";

     

       22
       22
        
         };

     

       23
       23
        
       

     

       24
       24
        
         propagatedBuildInputs = [

+9 -3

pkgs/development/python-modules/env-canada/default.nix

···

       8
       8
        
       , pillow

     

       9
       9
        
       , pytestCheckHook

     

       10
       10
        
       , python-dateutil

     

       11
       11
       +
       , pythonOlder

     

       11
       12
        
       , voluptuous

     

       12
       13
        
       }:

     

       13
       14
        
       

     

       14
       15
        
       buildPythonPackage rec {

     

       15
       16
        
         pname = "env-canada";

     

       16
       16
       -
         version = "0.5.16";

     

       17
       17
       +
         version = "0.5.17";

     

       18
       18
       +
         format = "setuptools";

     

       19
       19
       +
       

     

       20
       20
       +
         disabled = pythonOlder "3.8";

     

       17
       21
        
       

     

       18
       22
        
         src = fetchFromGitHub {

     

       19
       23
        
           owner = "michaeldavie";

     

       20
       24
        
           repo = "env_canada";

     

       21
       25
        
           rev = "v${version}";

     

       22
       22
       -
           sha256 = "sha256-5Cxpl5iwbBtpwQ9//yhEZNCIzBZgTm/fqAo9PNNxoG4=";

     

       26
       26
       +
           sha256 = "sha256-viuBuyGzAUcfb4qSecZsDvoAU++FNhuwNJET/s0qyOI=";

     

       23
       27
        
         };

     

       24
       28
        
       

     

       25
       29
        
         propagatedBuildInputs = [

     
···

       49
       53
        
           "test_ecradar"

     

       50
       54
        
         ];

     

       51
       55
        
       

     

       52
       52
       -
         pythonImportsCheck = [ "env_canada" ];

     

       56
       56
       +
         pythonImportsCheck = [

     

       57
       57
       +
           "env_canada"

     

       58
       58
       +
         ];

     

       53
       59
        
       

     

       54
       60
        
         meta = with lib; {

     

       55
       61
        
           description = "Python library to get Environment Canada weather data";

+4 -3

pkgs/development/python-modules/flux-led/default.nix

···

       7
       7
        
       }:

     

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
       -
         pname = "flux_led";

     

       11
       11
       -
         version = "0.24.24";

     

       10
       10
       +
         pname = "flux-led";

     

       11
       11
       +
         version = "0.24.25";

     

       12
       12
       +
         format = "setuptools";

     

       12
       13
        
       

     

       13
       14
        
         disabled = pythonOlder "3.7";

     

       14
       15
        
       

     
···

       16
       17
        
           owner = "Danielhiversen";

     

       17
       18
        
           repo = "flux_led";

     

       18
       19
        
           rev = version;

     

       19
       19
       -
           sha256 = "sha256-99EHmhyc6lAjYPHFvvqnd5r8HeEEJM6W3VK0/yLsz7I=";

     

       20
       20
       +
           sha256 = "sha256-HhoqsdaqNKdKH63glYEl5mRBFImu6Nxw5gwF7JAJABk=";

     

       20
       21
        
         };

     

       21
       22
        
       

     

       22
       23
        
         propagatedBuildInputs = [

+4

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

···

       12
       12
        
           sha256 = "0pfqfr5xqgsqkxzrmj8xl2glyl4nbq0irs0k6ik7iy3gd3mxf5g1";

     

       13
       13
        
         };

     

       14
       14
        
       

     

       15
       15
       +
         postPatch = ''

     

       16
       16
       +
           substituteInPlace setup.py --replace '"pytest-runner"' ""

     

       17
       17
       +
         '';

     

       18
       18
       +
       

     

       15
       19
        
         buildInputs = [ keyutils ];

     

       16
       20
        
         checkInputs = [ pytest pytest-runner ];

     

       17
       21

+11 -2

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

···

       1
       1
        
       { lib

     

       2
       2
        
       , buildPythonPackage

     

       3
       3
        
       , fetchPypi

     

       4
       4
       +
       , pytestCheckHook

     

       4
       5
        
       }:

     

       5
       6
        
       

     

       6
       7
        
       buildPythonPackage rec {

     

       7
       8
        
         pname = "oath";

     

       8
       8
       -
         version = "1.4.3";

     

       9
       9
       +
         version = "1.4.4";

     

       10
       10
       +
         format = "setuptools";

     

       9
       11
        
       

     

       10
       12
        
         src = fetchPypi {

     

       11
       13
        
           inherit pname version;

     

       12
       12
       -
           sha256 = "1xqgcqgx6aa0j21hwsdb3aqpqhviwj756bcqjjjcm1h1aij11p6m";

     

       14
       14
       +
           sha256 = "sha256-vWsg0g8sTj9TUj7pACEdynWu7KcvT1qf2NyswXX+HAs=";

     

       13
       15
        
         };

     

       16
       16
       +
         checkInputs = [

     

       17
       17
       +
           pytestCheckHook

     

       18
       18
       +
         ];

     

       19
       19
       +
       

     

       20
       20
       +
         pythonImportsCheck = [

     

       21
       21
       +
           "oath"

     

       22
       22
       +
         ];

     

       14
       23
        
       

     

       15
       24
        
         meta = with lib; {

     

       16
       25
        
           description = "Python implementation of the three main OATH specifications: HOTP, TOTP and OCRA";

+8 -4

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

···

       8
       8
        
       

     

       9
       9
        
       buildPythonPackage rec {

     

       10
       10
        
         pname = "pyads";

     

       11
       11
       -
         version = "3.3.8";

     

       12
       12
       -
         disabled = pythonOlder "3.6";

     

       11
       11
       +
         version = "3.3.9";

     

       12
       12
       +
         format = "setuptools";

     

       13
       13
       +
       

     

       14
       14
       +
         disabled = pythonOlder "3.7";

     

       13
       15
        
       

     

       14
       16
        
         src = fetchFromGitHub {

     

       15
       17
        
           owner = "stlehmann";

     

       16
       18
        
           repo = pname;

     

       17
       19
        
           rev = version;

     

       18
       18
       -
           sha256 = "sha256-jhEVBndUOKM8rBX0LEqPTMLqbpizCiD7T+OCzbVgLM8=";

     

       20
       20
       +
           sha256 = "sha256-eNouFJQDgp56fgkA7wZKfosKWOKU6OvXRjFwjCMvZqI=";

     

       19
       21
        
         };

     

       20
       22
        
       

     

       21
       23
        
         buildInputs = [

     
···

       31
       33
        
           pytestCheckHook

     

       32
       34
        
         ];

     

       33
       35
        
       

     

       34
       34
       -
         pythonImportsCheck = [ "pyads" ];

     

       36
       36
       +
         pythonImportsCheck = [

     

       37
       37
       +
           "pyads"

     

       38
       38
       +
         ];

     

       35
       39
        
       

     

       36
       40
        
         meta = with lib; {

     

       37
       41
        
           description = "Python wrapper for TwinCAT ADS library";

+5

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

···

       15
       15
        
           sha256 = "13x3718if28l50474xrz1b9709kvnvdg3nzm6y8bh7mc9a4zyss5";

     

       16
       16
        
         };

     

       17
       17
        
       

     

       18
       18
       +
         postPatch = ''

     

       19
       19
       +
           substituteInPlace unittests.py \

     

       20
       20
       +
               --replace '(tmp, "test.dat")' "(\"$TMPDIR\", \"test.dat\")"

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       18
       23
        
         checkInputs = [ pytestCheckHook ];

     

       19
       24
        
       

     

       20
       25
        
         pytestFlagsArray = [ "unittests.py" ];

+1 -1

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

···

       53
       53
        
           export FONTCONFIG_FILE=${fontsConf}

     

       54
       54
        
         '';

     

       55
       55
        
       

     

       56
       56
       -
         disabledTests = lib.optionals (!(stdenv.isi686 || stdenv.isx86_64)) [

     

       56
       56
       +
         disabledTests = lib.optionals (!stdenv.hostPlatform.isx86) [

     

       57
       57
        
           # small precision-related differences on other architectures,

     

       58
       58
        
           # upstream doesn't consider it serious.

     

       59
       59
        
           # https://github.com/pyqtgraph/pyqtgraph/issues/2110

+2 -2

pkgs/development/python-modules/qcs-api-client/default.nix

···

       18
       18
        
       

     

       19
       19
        
       buildPythonPackage rec {

     

       20
       20
        
         pname = "qcs-api-client";

     

       21
       21
       -
         version = "0.19.0";

     

       21
       21
       +
         version = "0.20.0";

     

       22
       22
        
         format = "setuptools";

     

       23
       23
        
       

     

       24
       24
        
         disabled = pythonOlder "3.7";

     

       25
       25
        
       

     

       26
       26
        
         src = fetchPypi {

     

       27
       27
        
           inherit pname version;

     

       28
       28
       -
           sha256 = "sha256-OfhOYvGcBzbirsD05D206b+mAOVvDVAwBvDgCKfXxSw=";

     

       28
       28
       +
           sha256 = "sha256-l6n/DUEWIBmnPvt5+TAZ2RnFrYEUwh4nIZa6aQG2lJ0=";

     

       29
       29
        
         };

     

       30
       30
        
       

     

       31
       31
        
         propagatedBuildInputs = [

+1 -1

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

···

       9
       9
        
             sha256 = "0pciv5by989vzvjxsv1jsv4bdp4m8j0nfbl29jm5fwi12w4603vj";

     

       10
       10
        
           };

     

       11
       11
        
         buildInputs = [ gpm freetype fontconfig ncurses ]

     

       12
       12
       -
           ++ lib.optional (stdenv.isi686 || stdenv.isx86_64) libx86;

     

       12
       12
       +
           ++ lib.optional stdenv.hostPlatform.isx86 libx86;

     

       13
       13
        
       in

     

       14
       14
        
       stdenv.mkDerivation {

     

       15
       15
        
         inherit (s) pname version;

+1 -1

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

···

       58
       58
        
           setuptools

     

       59
       59
        
         ]);

     

       60
       60
        
       

     

       61
       61
       -
         isx86 = stdenv.isx86_64 || stdenv.isi686;

     

       61
       61
       +
         isx86 = stdenv.hostPlatform.isx86;

     

       62
       62
        
       

     

       63
       63
        
         # Dell isn't supported on Aarch64

     

       64
       64
        
         haveDell = isx86;

+2 -2

pkgs/os-specific/linux/read-edid/default.nix

···

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         nativeBuildInputs = [ cmake ];

     

       13
       13
       -
         buildInputs = lib.optional (stdenv.isi686 || stdenv.isx86_64) libx86;

     

       13
       13
       +
         buildInputs = lib.optional stdenv.hostPlatform.isx86 libx86;

     

       14
       14
        
       

     

       15
       15
       -
         cmakeFlags = [ "-DCLASSICBUILD=${if stdenv.isi686 || stdenv.isx86_64 then "ON" else "OFF"}" ];

     

       15
       15
       +
         cmakeFlags = [ "-DCLASSICBUILD=${if stdenv.hostPlatform.isx86 then "ON" else "OFF"}" ];

     

       16
       16
        
       

     

       17
       17
        
         patchPhase = ''

     

       18
       18
        
           substituteInPlace CMakeLists.txt --replace 'COPYING' 'LICENSE'

+1 -1

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

···

       28
       28
        
         makeFlags = [

     

       29
       29
        
           "ARCH=${stdenv.hostPlatform.linuxArch}"

     

       30
       30
        
           "KSRC=${kernel.dev}/lib/modules/${kernel.modDirVersion}/build"

     

       31
       31
       -
           ("CONFIG_PLATFORM_I386_PC=" + (if (stdenv.hostPlatform.isi686 || stdenv.hostPlatform.isx86_64) then "y" else "n"))

     

       31
       31
       +
           ("CONFIG_PLATFORM_I386_PC=" + (if stdenv.hostPlatform.isx86 then "y" else "n"))

     

       32
       32
        
           ("CONFIG_PLATFORM_ARM_RPI=" + (if (stdenv.hostPlatform.isAarch32 || stdenv.hostPlatform.isAarch64) then "y" else "n"))

     

       33
       33
        
         ] ++ lib.optional (stdenv.hostPlatform != stdenv.buildPlatform) [

     

       34
       34
        
           "CROSS_COMPILE=${stdenv.cc.targetPrefix}"

+2 -2

pkgs/servers/icingaweb2/default.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "icingaweb2";

     

       5
       5
       -
         version = "2.9.3";

     

       5
       5
       +
         version = "2.9.4";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Icinga";

     

       9
       9
        
           repo = "icingaweb2";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-nPzf/SGyjEXuy0Q/Lofe1rSbW+4E6LXKzyi4np3jvF4=";

     

       11
       11
       +
           sha256 = "sha256:1fd5d2vhiq3s7qr4hnvnh9vv4ns7dvqwq8s67av89hjf3sqgw13j";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         nativeBuildInputs = [ makeWrapper ];

+2 -2

pkgs/servers/icingaweb2/ipl.nix

···

       2
       2
        
       

     

       3
       3
        
       stdenvNoCC.mkDerivation rec {

     

       4
       4
        
         pname = "icingaweb2-ipl";

     

       5
       5
       -
         version = "0.6.1";

     

       5
       5
       +
         version = "0.7.0";

     

       6
       6
        
       

     

       7
       7
        
         src = fetchFromGitHub {

     

       8
       8
        
           owner = "Icinga";

     

       9
       9
        
           repo = "icinga-php-library";

     

       10
       10
        
           rev = "v${version}";

     

       11
       11
       -
           sha256 = "sha256-5xlvwB1o6d3mWd0TSybQW9s88q6A7KrledY1L8xaxLU=";

     

       11
       11
       +
           sha256 = "sha256:118bg9mxjxajm2ydbycgqdmdx8przwxblsaxc373r0g1dp1lv0fz";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
        
         installPhase = ''

+384

pkgs/tools/compression/bsdiff/CVE-2020-14315.patch

···

       1
       1
       +
       Description: patch for CVE-2020-14315

     

       2
       2
       +
        A memory corruption vulnerability is present in bspatch as shipped in

     

       3
       3
       +
        Colin Percival’s bsdiff tools version 4.3. Insufficient checks when

     

       4
       4
       +
        handling external inputs allows an attacker to bypass the sanity checks

     

       5
       5
       +
        in place and write out of a dynamically allocated buffer boundaries.

     

       6
       6
       +
       Source: https://svnweb.freebsd.org/base/head/usr.bin/bsdiff/bspatch/bspatch.c?revision=352742&view=co

     

       7
       7
       +
       Author: tony mancill <tmancill@debian.org>

     

       8
       8
       +
       Comment: The patch was created by comparing the Debian sources to the

     

       9
       9
       +
        "Confirmed Patched Version" [1] documented in the

     

       10
       10
       +
        X41 D-SEC GmbH Security Advisory: X41-2020-006 [2].

     

       11
       11
       +
        References to FreeBSD capsicum have been dropped.  Definitions for

     

       12
       12
       +
        TYPE_MINIMUM and TYPE_MAXIMUM have been borrowed from the Debian

     

       13
       13
       +
        coreutils package sources but originate in gnulib [3] and are used to

     

       14
       14
       +
        define OFF_MIN and OFF_MAX (limits of off_t). Whitespace changes from

     

       15
       15
       +
        the confirmed patched version are also included and keep the difference

     

       16
       16
       +
        between the Debian sources and the confirmed patched version minimal.

     

       17
       17
       +
        .

     

       18
       18
       +
        [1] https://svnweb.freebsd.org/base/head/usr.bin/bsdiff/bspatch/bspatch.c?revision=352742&view=co

     

       19
       19
       +
        [2] https://www.openwall.com/lists/oss-security/2020/07/09/2

     

       20
       20
       +
        [3] https://www.gnu.org/software/gnulib/

     

       21
       21
       +
       Last-Update: 2021-04-03

     

       22
       22
       +
       Forwarded: not-needed

     

       23
       23
       +
       Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=964796

     

       24
       24
       +
       

     

       25
       25
       +
       --- a/bspatch.c

     

       26
       26
       +
       +++ b/bspatch.c

     

       27
       27
       +
       @@ -1,4 +1,6 @@

     

       28
       28
       +
        /*-

     

       29
       29
       +
       + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD

     

       30
       30
       +
       + *

     

       31
       31
       +
         * Copyright 2003-2005 Colin Percival

     

       32
       32
       +
         * All rights reserved

     

       33
       33
       +
         *

     

       34
       34
       +
       @@ -24,56 +26,148 @@

     

       35
       35
       +
         * POSSIBILITY OF SUCH DAMAGE.

     

       36
       36
       +
         */

     

       37
       37
       +
        

     

       38
       38
       +
       +#include <sys/cdefs.h>

     

       39
       39
       +
        #if 0

     

       40
       40
       +
       -__FBSDID("$FreeBSD: src/usr.bin/bsdiff/bspatch/bspatch.c,v 1.1 2005/08/06 01:59:06 cperciva Exp $");

     

       41
       41
       +
       +__FBSDID("$FreeBSD$");

     

       42
       42
       +
        #endif

     

       43
       43
       +
        

     

       44
       44
       +
        #include <bzlib.h>

     

       45
       45
       +
       -#include <stdlib.h>

     

       46
       46
       +
       +#include <err.h>

     

       47
       47
       +
       +#include <fcntl.h>

     

       48
       48
       +
       +#include <libgen.h>

     

       49
       49
       +
       +#include <limits.h>

     

       50
       50
       +
       +#include <stdint.h>

     

       51
       51
       +
        #include <stdio.h>

     

       52
       52
       +
       +#include <stdlib.h>

     

       53
       53
       +
        #include <string.h>

     

       54
       54
       +
       -#include <err.h>

     

       55
       55
       +
        #include <unistd.h>

     

       56
       56
       +
       -#include <fcntl.h>

     

       57
       57
       +
       +

     

       58
       58
       +
       +#ifndef O_BINARY

     

       59
       59
       +
       +#define O_BINARY 0

     

       60
       60
       +
       +#endif

     

       61
       61
       +
       +#define HEADER_SIZE 32

     

       62
       62
       +
       +

     

       63
       63
       +
       +/* TYPE_MINIMUM and TYPE_MAXIMUM taken from coreutils */

     

       64
       64
       +
       +#ifndef TYPE_MINIMUM

     

       65
       65
       +
       +#define TYPE_MINIMUM(t) \

     

       66
       66
       +
       +  ((t) ((t) 0 < (t) -1 ? (t) 0 : ~ TYPE_MAXIMUM (t)))

     

       67
       67
       +
       +#endif

     

       68
       68
       +
       +#ifndef TYPE_MAXIMUM

     

       69
       69
       +
       +#define TYPE_MAXIMUM(t) \

     

       70
       70
       +
       +  ((t) ((t) 0 < (t) -1 \

     

       71
       71
       +
       +        ? (t) -1 \

     

       72
       72
       +
       +        : ((((t) 1 << (sizeof (t) * CHAR_BIT - 2)) - 1) * 2 + 1)))

     

       73
       73
       +
       +#endif

     

       74
       74
       +
       +

     

       75
       75
       +
       +#ifndef OFF_MAX

     

       76
       76
       +
       +#define OFF_MAX TYPE_MAXIMUM(off_t)

     

       77
       77
       +
       +#endif

     

       78
       78
       +
       +

     

       79
       79
       +
       +#ifndef OFF_MIN

     

       80
       80
       +
       +#define OFF_MIN TYPE_MINIMUM(off_t)

     

       81
       81
       +
       +#endif

     

       82
       82
       +
       +

     

       83
       83
       +
       +static char *newfile;

     

       84
       84
       +
       +static int dirfd = -1;

     

       85
       85
       +
       +

     

       86
       86
       +
       +static void

     

       87
       87
       +
       +exit_cleanup(void)

     

       88
       88
       +
       +{

     

       89
       89
       +
       +

     

       90
       90
       +
       +	if (dirfd != -1 && newfile != NULL)

     

       91
       91
       +
       +		if (unlinkat(dirfd, newfile, 0))

     

       92
       92
       +
       +			warn("unlinkat");

     

       93
       93
       +
       +}

     

       94
       94
       +
       +

     

       95
       95
       +
       +static inline off_t

     

       96
       96
       +
       +add_off_t(off_t a, off_t b)

     

       97
       97
       +
       +{

     

       98
       98
       +
       +	off_t result;

     

       99
       99
       +
       +

     

       100
       100
       +
       +#if __GNUC__ >= 5

     

       101
       101
       +
       +	if (__builtin_add_overflow(a, b, &result))

     

       102
       102
       +
       +		errx(1, "Corrupt patch");

     

       103
       103
       +
       +#else

     

       104
       104
       +
       +	if ((b > 0 && a > OFF_MAX - b) || (b < 0 && a < OFF_MIN - b))

     

       105
       105
       +
       +		errx(1, "Corrupt patch");

     

       106
       106
       +
       +	result = a + b;

     

       107
       107
       +
       +#endif

     

       108
       108
       +
       +	return result;

     

       109
       109
       +
       +}

     

       110
       110
       +
        

     

       111
       111
       +
        static off_t offtin(u_char *buf)

     

       112
       112
       +
        {

     

       113
       113
       +
        	off_t y;

     

       114
       114
       +
        

     

       115
       115
       +
       -	y=buf[7]&0x7F;

     

       116
       116
       +
       -	y=y*256;y+=buf[6];

     

       117
       117
       +
       -	y=y*256;y+=buf[5];

     

       118
       118
       +
       -	y=y*256;y+=buf[4];

     

       119
       119
       +
       -	y=y*256;y+=buf[3];

     

       120
       120
       +
       -	y=y*256;y+=buf[2];

     

       121
       121
       +
       -	y=y*256;y+=buf[1];

     

       122
       122
       +
       -	y=y*256;y+=buf[0];

     

       123
       123
       +
       +	y = buf[7] & 0x7F;

     

       124
       124
       +
       +	y = y * 256; y += buf[6];

     

       125
       125
       +
       +	y = y * 256; y += buf[5];

     

       126
       126
       +
       +	y = y * 256; y += buf[4];

     

       127
       127
       +
       +	y = y * 256; y += buf[3];

     

       128
       128
       +
       +	y = y * 256; y += buf[2];

     

       129
       129
       +
       +	y = y * 256; y += buf[1];

     

       130
       130
       +
       +	y = y * 256; y += buf[0];

     

       131
       131
       +
        

     

       132
       132
       +
       -	if(buf[7]&0x80) y=-y;

     

       133
       133
       +
       +	if (buf[7] & 0x80)

     

       134
       134
       +
       +		y = -y;

     

       135
       135
       +
        

     

       136
       136
       +
       -	return y;

     

       137
       137
       +
       +	return (y);

     

       138
       138
       +
        }

     

       139
       139
       +
        

     

       140
       140
       +
       -int main(int argc,char * argv[])

     

       141
       141
       +
       +static void

     

       142
       142
       +
       +usage(void)

     

       143
       143
       +
        {

     

       144
       144
       +
       -	FILE * f, * cpf, * dpf, * epf;

     

       145
       145
       +
       -	BZFILE * cpfbz2, * dpfbz2, * epfbz2;

     

       146
       146
       +
       +

     

       147
       147
       +
       +	fprintf(stderr, "usage: bspatch oldfile newfile patchfile\n");

     

       148
       148
       +
       +	exit(1);

     

       149
       149
       +
       +}

     

       150
       150
       +
       +

     

       151
       151
       +
       +int main(int argc, char *argv[])

     

       152
       152
       +
       +{

     

       153
       153
       +
       +	FILE *f, *cpf, *dpf, *epf;

     

       154
       154
       +
       +	BZFILE *cpfbz2, *dpfbz2, *epfbz2;

     

       155
       155
       +
       +	char *directory, *namebuf;

     

       156
       156
       +
        	int cbz2err, dbz2err, ebz2err;

     

       157
       157
       +
       -	int fd;

     

       158
       158
       +
       -	ssize_t oldsize,newsize;

     

       159
       159
       +
       -	ssize_t bzctrllen,bzdatalen;

     

       160
       160
       +
       -	u_char header[32],buf[8];

     

       161
       161
       +
       +	int newfd, oldfd;

     

       162
       162
       +
       +	off_t oldsize, newsize;

     

       163
       163
       +
       +	off_t bzctrllen, bzdatalen;

     

       164
       164
       +
       +	u_char header[HEADER_SIZE], buf[8];

     

       165
       165
       +
        	u_char *old, *new;

     

       166
       166
       +
       -	off_t oldpos,newpos;

     

       167
       167
       +
       +	off_t oldpos, newpos;

     

       168
       168
       +
        	off_t ctrl[3];

     

       169
       169
       +
       -	off_t lenread;

     

       170
       170
       +
       -	off_t i;

     

       171
       171
       +
       +	off_t i, lenread, offset;

     

       172
       172
       +
        

     

       173
       173
       +
       -	if(argc!=4) errx(1,"usage: %s oldfile newfile patchfile\n",argv[0]);

     

       174
       174
       +
       +	if (argc != 4)

     

       175
       175
       +
       +		usage();

     

       176
       176
       +
        

     

       177
       177
       +
        	/* Open patch file */

     

       178
       178
       +
       -	if ((f = fopen(argv[3], "r")) == NULL)

     

       179
       179
       +
       +	if ((f = fopen(argv[3], "rb")) == NULL)

     

       180
       180
       +
       +		err(1, "fopen(%s)", argv[3]);

     

       181
       181
       +
       +	/* Open patch file for control block */

     

       182
       182
       +
       +	if ((cpf = fopen(argv[3], "rb")) == NULL)

     

       183
       183
       +
       +		err(1, "fopen(%s)", argv[3]);

     

       184
       184
       +
       +	/* open patch file for diff block */

     

       185
       185
       +
       +	if ((dpf = fopen(argv[3], "rb")) == NULL)

     

       186
       186
       +
        		err(1, "fopen(%s)", argv[3]);

     

       187
       187
       +
       +	/* open patch file for extra block */

     

       188
       188
       +
       +	if ((epf = fopen(argv[3], "rb")) == NULL)

     

       189
       189
       +
       +		err(1, "fopen(%s)", argv[3]);

     

       190
       190
       +
       +	/* open oldfile */

     

       191
       191
       +
       +	if ((oldfd = open(argv[1], O_RDONLY | O_BINARY, 0)) < 0)

     

       192
       192
       +
       +		err(1, "open(%s)", argv[1]);

     

       193
       193
       +
       +	/* open directory where we'll write newfile */

     

       194
       194
       +
       +	if ((namebuf = strdup(argv[2])) == NULL ||

     

       195
       195
       +
       +	    (directory = dirname(namebuf)) == NULL ||

     

       196
       196
       +
       +	    (dirfd = open(directory, O_DIRECTORY)) < 0)

     

       197
       197
       +
       +		err(1, "open %s", argv[2]);

     

       198
       198
       +
       +	free(namebuf);

     

       199
       199
       +
       +	if ((newfile = basename(argv[2])) == NULL)

     

       200
       200
       +
       +		err(1, "basename");

     

       201
       201
       +
       +	/* open newfile */

     

       202
       202
       +
       +	if ((newfd = openat(dirfd, newfile,

     

       203
       203
       +
       +	    O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0666)) < 0)

     

       204
       204
       +
       +		err(1, "open(%s)", argv[2]);

     

       205
       205
       +
       +	atexit(exit_cleanup);

     

       206
       206
       +
        

     

       207
       207
       +
        	/*

     

       208
       208
       +
        	File format:

     

       209
       209
       +
       @@ -90,104 +185,104 @@

     

       210
       210
       +
        	*/

     

       211
       211
       +
        

     

       212
       212
       +
        	/* Read header */

     

       213
       213
       +
       -	if (fread(header, 1, 32, f) < 32) {

     

       214
       214
       +
       +	if (fread(header, 1, HEADER_SIZE, f) < HEADER_SIZE) {

     

       215
       215
       +
        		if (feof(f))

     

       216
       216
       +
       -			errx(1, "Corrupt patch\n");

     

       217
       217
       +
       +			errx(1, "Corrupt patch");

     

       218
       218
       +
        		err(1, "fread(%s)", argv[3]);

     

       219
       219
       +
        	}

     

       220
       220
       +
        

     

       221
       221
       +
        	/* Check for appropriate magic */

     

       222
       222
       +
        	if (memcmp(header, "BSDIFF40", 8) != 0)

     

       223
       223
       +
       -		errx(1, "Corrupt patch\n");

     

       224
       224
       +
       +		errx(1, "Corrupt patch");

     

       225
       225
       +
        

     

       226
       226
       +
        	/* Read lengths from header */

     

       227
       227
       +
       -	bzctrllen=offtin(header+8);

     

       228
       228
       +
       -	bzdatalen=offtin(header+16);

     

       229
       229
       +
       -	newsize=offtin(header+24);

     

       230
       230
       +
       -	if((bzctrllen<0) || (bzdatalen<0) || (newsize<0))

     

       231
       231
       +
       -		errx(1,"Corrupt patch\n");

     

       232
       232
       +
       +	bzctrllen = offtin(header + 8);

     

       233
       233
       +
       +	bzdatalen = offtin(header + 16);

     

       234
       234
       +
       +	newsize = offtin(header + 24);

     

       235
       235
       +
       +	if (bzctrllen < 0 || bzctrllen > OFF_MAX - HEADER_SIZE ||

     

       236
       236
       +
       +	    bzdatalen < 0 || bzctrllen + HEADER_SIZE > OFF_MAX - bzdatalen ||

     

       237
       237
       +
       +	    newsize < 0 || newsize > SSIZE_MAX)

     

       238
       238
       +
       +		errx(1, "Corrupt patch");

     

       239
       239
       +
        

     

       240
       240
       +
        	/* Close patch file and re-open it via libbzip2 at the right places */

     

       241
       241
       +
        	if (fclose(f))

     

       242
       242
       +
        		err(1, "fclose(%s)", argv[3]);

     

       243
       243
       +
       -	if ((cpf = fopen(argv[3], "r")) == NULL)

     

       244
       244
       +
       -		err(1, "fopen(%s)", argv[3]);

     

       245
       245
       +
       -	if (fseeko(cpf, 32, SEEK_SET))

     

       246
       246
       +
       -		err(1, "fseeko(%s, %lld)", argv[3],

     

       247
       247
       +
       -		    (long long)32);

     

       248
       248
       +
       +	offset = HEADER_SIZE;

     

       249
       249
       +
       +	if (fseeko(cpf, offset, SEEK_SET))

     

       250
       250
       +
       +		err(1, "fseeko(%s, %jd)", argv[3], (intmax_t)offset);

     

       251
       251
       +
        	if ((cpfbz2 = BZ2_bzReadOpen(&cbz2err, cpf, 0, 0, NULL, 0)) == NULL)

     

       252
       252
       +
        		errx(1, "BZ2_bzReadOpen, bz2err = %d", cbz2err);

     

       253
       253
       +
       -	if ((dpf = fopen(argv[3], "r")) == NULL)

     

       254
       254
       +
       -		err(1, "fopen(%s)", argv[3]);

     

       255
       255
       +
       -	if (fseeko(dpf, 32 + bzctrllen, SEEK_SET))

     

       256
       256
       +
       -		err(1, "fseeko(%s, %lld)", argv[3],

     

       257
       257
       +
       -		    (long long)(32 + bzctrllen));

     

       258
       258
       +
       +	offset = add_off_t(offset, bzctrllen);

     

       259
       259
       +
       +	if (fseeko(dpf, offset, SEEK_SET))

     

       260
       260
       +
       +		err(1, "fseeko(%s, %jd)", argv[3], (intmax_t)offset);

     

       261
       261
       +
        	if ((dpfbz2 = BZ2_bzReadOpen(&dbz2err, dpf, 0, 0, NULL, 0)) == NULL)

     

       262
       262
       +
        		errx(1, "BZ2_bzReadOpen, bz2err = %d", dbz2err);

     

       263
       263
       +
       -	if ((epf = fopen(argv[3], "r")) == NULL)

     

       264
       264
       +
       -		err(1, "fopen(%s)", argv[3]);

     

       265
       265
       +
       -	if (fseeko(epf, 32 + bzctrllen + bzdatalen, SEEK_SET))

     

       266
       266
       +
       -		err(1, "fseeko(%s, %lld)", argv[3],

     

       267
       267
       +
       -		    (long long)(32 + bzctrllen + bzdatalen));

     

       268
       268
       +
       +	offset = add_off_t(offset, bzdatalen);

     

       269
       269
       +
       +	if (fseeko(epf, offset, SEEK_SET))

     

       270
       270
       +
       +		err(1, "fseeko(%s, %jd)", argv[3], (intmax_t)offset);

     

       271
       271
       +
        	if ((epfbz2 = BZ2_bzReadOpen(&ebz2err, epf, 0, 0, NULL, 0)) == NULL)

     

       272
       272
       +
        		errx(1, "BZ2_bzReadOpen, bz2err = %d", ebz2err);

     

       273
       273
       +
        

     

       274
       274
       +
       -	if(((fd=open(argv[1],O_RDONLY,0))<0) ||

     

       275
       275
       +
       -		((oldsize=lseek(fd,0,SEEK_END))==-1) ||

     

       276
       276
       +
       -		((old=malloc(oldsize+1))==NULL) ||

     

       277
       277
       +
       -		(lseek(fd,0,SEEK_SET)!=0) ||

     

       278
       278
       +
       -		(read(fd,old,oldsize)!=oldsize) ||

     

       279
       279
       +
       -		(close(fd)==-1)) err(1,"%s",argv[1]);

     

       280
       280
       +
       -	if((new=malloc(newsize+1))==NULL) err(1,NULL);

     

       281
       281
       +
       -

     

       282
       282
       +
       -	oldpos=0;newpos=0;

     

       283
       283
       +
       -	while(newpos<newsize) {

     

       284
       284
       +
       +	if ((oldsize = lseek(oldfd, 0, SEEK_END)) == -1 ||

     

       285
       285
       +
       +	    oldsize > SSIZE_MAX ||

     

       286
       286
       +
       +	    (old = malloc(oldsize)) == NULL ||

     

       287
       287
       +
       +	    lseek(oldfd, 0, SEEK_SET) != 0 ||

     

       288
       288
       +
       +	    read(oldfd, old, oldsize) != oldsize ||

     

       289
       289
       +
       +	    close(oldfd) == -1)

     

       290
       290
       +
       +		err(1, "%s", argv[1]);

     

       291
       291
       +
       +	if ((new = malloc(newsize)) == NULL)

     

       292
       292
       +
       +		err(1, NULL);

     

       293
       293
       +
       +

     

       294
       294
       +
       +	oldpos = 0;

     

       295
       295
       +
       +	newpos = 0;

     

       296
       296
       +
       +	while (newpos < newsize) {

     

       297
       297
       +
        		/* Read control data */

     

       298
       298
       +
       -		for(i=0;i<=2;i++) {

     

       299
       299
       +
       +		for (i = 0; i <= 2; i++) {

     

       300
       300
       +
        			lenread = BZ2_bzRead(&cbz2err, cpfbz2, buf, 8);

     

       301
       301
       +
        			if ((lenread < 8) || ((cbz2err != BZ_OK) &&

     

       302
       302
       +
        			    (cbz2err != BZ_STREAM_END)))

     

       303
       303
       +
       -				errx(1, "Corrupt patch\n");

     

       304
       304
       +
       -			ctrl[i]=offtin(buf);

     

       305
       305
       +
       -		};

     

       306
       306
       +
       +				errx(1, "Corrupt patch");

     

       307
       307
       +
       +			ctrl[i] = offtin(buf);

     

       308
       308
       +
       +		}

     

       309
       309
       +
        

     

       310
       310
       +
        		/* Sanity-check */

     

       311
       311
       +
       -		if ((ctrl[0] < 0) || (ctrl[1] < 0))

     

       312
       312
       +
       -			errx(1,"Corrupt patch\n");

     

       313
       313
       +
       +		if (ctrl[0] < 0 || ctrl[0] > INT_MAX ||

     

       314
       314
       +
       +		    ctrl[1] < 0 || ctrl[1] > INT_MAX)

     

       315
       315
       +
       +			errx(1, "Corrupt patch");

     

       316
       316
       +
        

     

       317
       317
       +
        		/* Sanity-check */

     

       318
       318
       +
       -		if(newpos+ctrl[0]>newsize)

     

       319
       319
       +
       -			errx(1,"Corrupt patch\n");

     

       320
       320
       +
       +		if (add_off_t(newpos, ctrl[0]) > newsize)

     

       321
       321
       +
       +			errx(1, "Corrupt patch");

     

       322
       322
       +
        

     

       323
       323
       +
        		/* Read diff string */

     

       324
       324
       +
        		lenread = BZ2_bzRead(&dbz2err, dpfbz2, new + newpos, ctrl[0]);

     

       325
       325
       +
        		if ((lenread < ctrl[0]) ||

     

       326
       326
       +
        		    ((dbz2err != BZ_OK) && (dbz2err != BZ_STREAM_END)))

     

       327
       327
       +
       -			errx(1, "Corrupt patch\n");

     

       328
       328
       +
       +			errx(1, "Corrupt patch");

     

       329
       329
       +
        

     

       330
       330
       +
        		/* Add old data to diff string */

     

       331
       331
       +
       -		for(i=0;i<ctrl[0];i++)

     

       332
       332
       +
       -			if((oldpos+i>=0) && (oldpos+i<oldsize))

     

       333
       333
       +
       -				new[newpos+i]+=old[oldpos+i];

     

       334
       334
       +
       +		for (i = 0; i < ctrl[0]; i++)

     

       335
       335
       +
       +			if (add_off_t(oldpos, i) < oldsize)

     

       336
       336
       +
       +				new[newpos + i] += old[oldpos + i];

     

       337
       337
       +
        

     

       338
       338
       +
        		/* Adjust pointers */

     

       339
       339
       +
       -		newpos+=ctrl[0];

     

       340
       340
       +
       -		oldpos+=ctrl[0];

     

       341
       341
       +
       +		newpos = add_off_t(newpos, ctrl[0]);

     

       342
       342
       +
       +		oldpos = add_off_t(oldpos, ctrl[0]);

     

       343
       343
       +
        

     

       344
       344
       +
        		/* Sanity-check */

     

       345
       345
       +
       -		if(newpos+ctrl[1]>newsize)

     

       346
       346
       +
       -			errx(1,"Corrupt patch\n");

     

       347
       347
       +
       +		if (add_off_t(newpos, ctrl[1]) > newsize)

     

       348
       348
       +
       +			errx(1, "Corrupt patch");

     

       349
       349
       +
        

     

       350
       350
       +
        		/* Read extra string */

     

       351
       351
       +
        		lenread = BZ2_bzRead(&ebz2err, epfbz2, new + newpos, ctrl[1]);

     

       352
       352
       +
        		if ((lenread < ctrl[1]) ||

     

       353
       353
       +
        		    ((ebz2err != BZ_OK) && (ebz2err != BZ_STREAM_END)))

     

       354
       354
       +
       -			errx(1, "Corrupt patch\n");

     

       355
       355
       +
       +			errx(1, "Corrupt patch");

     

       356
       356
       +
        

     

       357
       357
       +
        		/* Adjust pointers */

     

       358
       358
       +
       -		newpos+=ctrl[1];

     

       359
       359
       +
       -		oldpos+=ctrl[2];

     

       360
       360
       +
       -	};

     

       361
       361
       +
       +		newpos = add_off_t(newpos, ctrl[1]);

     

       362
       362
       +
       +		oldpos = add_off_t(oldpos, ctrl[2]);

     

       363
       363
       +
       +	}

     

       364
       364
       +
        

     

       365
       365
       +
        	/* Clean up the bzip2 reads */

     

       366
       366
       +
        	BZ2_bzReadClose(&cbz2err, cpfbz2);

     

       367
       367
       +
       @@ -197,12 +292,13 @@

     

       368
       368
       +
        		err(1, "fclose(%s)", argv[3]);

     

       369
       369
       +
        

     

       370
       370
       +
        	/* Write the new file */

     

       371
       371
       +
       -	if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0666))<0) ||

     

       372
       372
       +
       -		(write(fd,new,newsize)!=newsize) || (close(fd)==-1))

     

       373
       373
       +
       -		err(1,"%s",argv[2]);

     

       374
       374
       +
       +	if (write(newfd, new, newsize) != newsize || close(newfd) == -1)

     

       375
       375
       +
       +		err(1, "%s", argv[2]);

     

       376
       376
       +
       +	/* Disable atexit cleanup */

     

       377
       377
       +
       +	newfile = NULL;

     

       378
       378
       +
        

     

       379
       379
       +
        	free(new);

     

       380
       380
       +
        	free(old);

     

       381
       381
       +
        

     

       382
       382
       +
       -	return 0;

     

       383
       383
       +
       +	return (0);

     

       384
       384
       +
        }

+22 -2

pkgs/tools/compression/bsdiff/default.nix

···

       1
       1
       -
       { lib, stdenv, fetchurl, bzip2 }:

     

       1
       1
       +
       { lib, stdenv, fetchurl, fetchpatch, bzip2 }:

     

       2
       2
        
       

     

       3
       3
        
       stdenv.mkDerivation rec {

     

       4
       4
        
         pname = "bsdiff";

     
···

       10
       10
        
         };

     

       11
       11
        
       

     

       12
       12
        
         buildInputs = [ bzip2 ];

     

       13
       13
       -
         patches = [ ./include-systypes.patch ];

     

       13
       13
       +
         patches = [

     

       14
       14
       +
           (fetchpatch {

     

       15
       15
       +
             url = "https://sources.debian.org/data/main/b/bsdiff/4.3-22/debian/patches/20-CVE-2014-9862.patch";

     

       16
       16
       +
             sha256 = "sha256-3UuUfNvShQ8fLqxCKUTb/n4BmjL4+Nl7aEqCxYrrERQ=";

     

       17
       17
       +
           })

     

       18
       18
       +
           ./CVE-2020-14315.patch

     

       19
       19
       +
           ./include-systypes.patch

     

       20
       20
       +
         ] ++ lib.optional stdenv.hostPlatform.isLinux [

     

       21
       21
       +
           (fetchpatch {

     

       22
       22
       +
             url = "https://sources.debian.org/data/main/b/bsdiff/4.3-22/debian/patches/30-bug-632585-mmap-src-file-instead-of-malloc-read-it.patch";

     

       23
       23
       +
             sha256 = "sha256-esbhz2/efUiuQDuF7LGfSeEn3/f1WbqCxQpTs2A0ulI=";

     

       24
       24
       +
           })

     

       25
       25
       +
           (fetchpatch {

     

       26
       26
       +
             url = "https://sources.debian.org/data/main/b/bsdiff/4.3-22/debian/patches/31-bug-632585-mmap-dst-file-instead-of-malloc-read-it.patch";

     

       27
       27
       +
             sha256 = "sha256-Of4aOcI0rsgdRzPqyw2VRn2p9wQuo3hdlgDTBdXGzoc=";

     

       28
       28
       +
           })

     

       29
       29
       +
           (fetchpatch {

     

       30
       30
       +
             url = "https://sources.debian.org/data/main/b/bsdiff/4.3-22/debian/patches/32-bug-632585-use-int32_t-instead-off_t-for-file-size.patch";

     

       31
       31
       +
             sha256 = "sha256-SooFnFK4uKNXvXQb/LEcH8GocnRtkryExI4b3BZTsAY=";

     

       32
       32
       +
           })

     

       33
       33
       +
         ];

     

       14
       34
        
       

     

       15
       35
        
         buildPhase = ''

     

       16
       36
        
           $CC -O3 -lbz2 bspatch.c -o bspatch

+1 -1

pkgs/tools/graphics/pngquant/default.nix

···

       14
       14
        
       

     

       15
       15
        
         preConfigure = "patchShebangs .";

     

       16
       16
        
       

     

       17
       17
       -
         configureFlags = lib.optionals (!stdenv.isi686 && !stdenv.isx86_64) [ "--disable-sse" ];

     

       17
       17
       +
         configureFlags = lib.optionals (!stdenv.hostPlatform.isx86) [ "--disable-sse" ];

     

       18
       18
        
       

     

       19
       19
        
         nativeBuildInputs = [ pkg-config ];

     

       20
       20
        
         buildInputs = [ libpng zlib lcms2 ];

+5 -2

pkgs/tools/misc/fluent-bit/default.nix

···

       11
       11
        
           sha256 = "sha256-b+MZuZQB/sl0HcioU1KCxH3TNiXYSPBfC9dBKqCVeXk=";

     

       12
       12
        
         };

     

       13
       13
        
       

     

       14
       14
       +
         patches = lib.optionals stdenv.isDarwin [

     

       15
       15
       +
           ./fix-cmetrics-darwin.patch

     

       16
       16
       +
           ./fix-luajit-darwin.patch

     

       17
       17
       +
         ];

     

       18
       18
       +
       

     

       14
       19
        
         nativeBuildInputs = [ cmake flex bison ];

     

       15
       20
        
       

     

       16
       21
        
         buildInputs = lib.optionals stdenv.isLinux [ systemd ];

     

       17
       22
        
       

     

       18
       23
        
         cmakeFlags = [ "-DFLB_METRICS=ON" "-DFLB_HTTP_SERVER=ON" ];

     

       19
       19
       -
       

     

       20
       20
       -
         patches = lib.optionals stdenv.isDarwin [ ./fix-luajit-darwin.patch ];

     

       21
       24
        
       

     

       22
       25
        
         # _FORTIFY_SOURCE requires compiling with optimization (-O)

     

       23
       26
        
         NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isGNU "-O";

+23

pkgs/tools/misc/fluent-bit/fix-cmetrics-darwin.patch

···

       1
       1
       +
       diff --git i/lib/cmetrics/src/cmt_time.c w/lib/cmetrics/src/cmt_time.c

     

       2
       2
       +
       --- i/lib/cmetrics/src/cmt_time.c

     

       3
       3
       +
       +++ w/lib/cmetrics/src/cmt_time.c

     

       4
       4
       +
       @@ -20,7 +20,7 @@

     

       5
       5
       +
        #include <cmetrics/cmt_info.h>

     

       6
       6
       +
        

     

       7
       7
       +
        /* MacOS */

     

       8
       8
       +
       -#ifdef FLB_HAVE_CLOCK_GET_TIME

     

       9
       9
       +
       +#ifdef CMT_HAVE_CLOCK_GET_TIME

     

       10
       10
       +
        #include <mach/clock.h>

     

       11
       11
       +
        #include <mach/mach.h>

     

       12
       12
       +
        #endif

     

       13
       13
       +
       @@ -41,8 +41,8 @@

     

       14
       14
       +
            mach_timespec_t mts;

     

       15
       15
       +
            host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);

     

       16
       16
       +
            clock_get_time(cclock, &mts);

     

       17
       17
       +
       -    tm->tv_sec = mts.tv_sec;

     

       18
       18
       +
       -    tm->tv_nsec = mts.tv_nsec;

     

       19
       19
       +
       +    tm.tv_sec = mts.tv_sec;

     

       20
       20
       +
       +    tm.tv_nsec = mts.tv_nsec;

     

       21
       21
       +
            mach_port_deallocate(mach_task_self(), cclock);

     

       22
       22
       +
        #else /* __STDC_VERSION__ */

     

       23
       23
       +
            clock_gettime(CLOCK_REALTIME, &tm);

+23 -8

pkgs/tools/misc/fluent-bit/fix-luajit-darwin.patch

···

       1
       1
        
       diff -Naur fluent-bit.old/cmake/luajit.cmake fluent-bit.new/cmake/luajit.cmake

     

       2
       2
        
       --- fluent-bit.old/cmake/luajit.cmake

     

       3
       3
        
       +++ fluent-bit.new/cmake/luajit.cmake

     

       4
       4
       -
       @@ -11,10 +11,6 @@

     

       5
       5
       -
        set(LUAJIT_SRC ${CMAKE_CURRENT_SOURCE_DIR}/${FLB_PATH_LIB_LUAJIT})

     

       4
       4
       +
       @@ -12,15 +12,7 @@

     

       6
       5
        
        set(LUAJIT_DEST ${CMAKE_CURRENT_BINARY_DIR})

     

       7
       6
        
        

     

       8
       8
       -
       -if (CMAKE_SYSTEM_NAME MATCHES "Darwin")

     

       9
       9
       -
       -  set(CFLAGS "${CFLAGS} -isysroot ${CMAKE_OSX_SYSROOT}")

     

       10
       10
       -
       -endif()

     

       11
       11
       -
       -

     

       7
       7
       +
        if (CMAKE_SYSTEM_NAME MATCHES "Darwin")

     

       8
       8
       +
       -  set(CFLAGS "${CFLAGS} -isysroot ${CMAKE_OSX_SYSROOT} -fno-stack-check")

     

       9
       9
       +
       -  if (CMAKE_HOST_SYSTEM_VERSION VERSION_GREATER_EQUAL 20

     

       10
       10
       +
       -      AND CMAKE_HOST_SYSTEM_VERSION VERSION_LESS 21)

     

       11
       11
       +
       -    set(DEPLOYMENT_TARGET "MACOSX_DEPLOYMENT_TARGET=11.0")

     

       12
       12
       +
       -  else()

     

       13
       13
       +
       -    set(DEPLOYMENT_TARGET "MACOSX_DEPLOYMENT_TARGET=10.15")

     

       14
       14
       +
       -  endif()

     

       15
       15
       +
       -else()

     

       16
       16
       +
       -  set(DEPLOYMENT_TARGET "")

     

       17
       17
       +
       +  set(CFLAGS "${CFLAGS} -fno-stack-check")

     

       18
       18
       +
        endif()

     

       19
       19
       +
        

     

       12
       20
        
        # luajit (UNIX)

     

       13
       13
       -
        # =============

     

       14
       14
       -
        ExternalProject_Add(luajit

     

       21
       21
       +
       @@ -30,7 +22,7 @@

     

       22
       22
       +
          EXCLUDE_FROM_ALL TRUE

     

       23
       23
       +
          SOURCE_DIR ${LUAJIT_SRC}

     

       24
       24
       +
          CONFIGURE_COMMAND ./configure

     

       25
       25
       +
       -  BUILD_COMMAND $(MAKE) CROSS=${CROSS_PREFIX} CFLAGS=${CFLAGS} BUILD_MODE=static "XCFLAGS=-fPIC" ${DEPLOYMENT_TARGET}

     

       26
       26
       +
       +  BUILD_COMMAND $(MAKE) DEFAULT_CC=cc CROSS=${CROSS_PREFIX} CFLAGS=${CFLAGS} BUILD_MODE=static "XCFLAGS=-fPIC"

     

       27
       27
       +
          INSTALL_COMMAND cp src/libluajit.a "${LUAJIT_DEST}/lib/libluajit.a")

     

       28
       28
       +
        

     

       29
       29
       +
        # luajit (Windows)

+3 -3

pkgs/tools/misc/ipxe/default.nix

···

       9
       9
        
           "bin-x86_64-efi/ipxe.efi" = null;

     

       10
       10
        
           "bin-x86_64-efi/ipxe.efirom" = null;

     

       11
       11
        
           "bin-x86_64-efi/ipxe.usb" = "ipxe-efi.usb";

     

       12
       12
       -
         } // lib.optionalAttrs (stdenv.isi686 || stdenv.isx86_64) {

     

       12
       12
       +
         } // lib.optionalAttrs stdenv.hostPlatform.isx86 {

     

       13
       13
        
           "bin/ipxe.dsk" = null;

     

       14
       14
        
           "bin/ipxe.usb" = null;

     

       15
       15
        
           "bin/ipxe.iso" = null;

     
···

       30
       30
        
         pname = "ipxe";

     

       31
       31
        
         version = "1.21.1";

     

       32
       32
        
       

     

       33
       33
       -
         nativeBuildInputs = [ perl cdrkit xz openssl gnu-efi mtools ] ++ lib.optional (stdenv.isi686 || stdenv.isx86_64) syslinux;

     

       33
       33
       +
         nativeBuildInputs = [ perl cdrkit xz openssl gnu-efi mtools ] ++ lib.optional stdenv.hostPlatform.isx86 syslinux;

     

       34
       34
        
       

     

       35
       35
        
         src = fetchFromGitHub {

     

       36
       36
        
           owner = "ipxe";

     
···

       46
       46
        
       

     

       47
       47
        
         makeFlags =

     

       48
       48
        
           [ "ECHO_E_BIN_ECHO=echo" "ECHO_E_BIN_ECHO_E=echo" # No /bin/echo here.

     

       49
       49
       -
           ] ++ lib.optionals (stdenv.isi686 || stdenv.isx86_64) [

     

       49
       49
       +
           ] ++ lib.optionals stdenv.hostPlatform.isx86 [

     

       50
       50
        
             "ISOLINUX_BIN_LIST=${syslinux}/share/syslinux/isolinux.bin"

     

       51
       51
        
             "LDLINUX_C32=${syslinux}/share/syslinux/ldlinux.c32"

     

       52
       52
        
           ] ++ lib.optional (embedScript != null) "EMBED=${embedScript}";

+1 -1

pkgs/tools/networking/fastd/default.nix

···

       42
       42
        
         ];

     

       43
       43
        
       

     

       44
       44
        
         # some options are only available on x86

     

       45
       45
       -
         mesonFlags = lib.optionals (!stdenv.isx86_64 && !stdenv.isi686) [

     

       45
       45
       +
         mesonFlags = lib.optionals (!stdenv.hostPlatform.isx86) [

     

       46
       46
        
           "-Dcipher_salsa20_xmm=disabled"

     

       47
       47
        
           "-Dcipher_salsa2012_xmm=disabled"

     

       48
       48
        
           "-Dmac_ghash_pclmulqdq=disabled"

+1 -1

pkgs/tools/security/mkp224o/default.nix

···

       18
       18
        
             variants = [

     

       19
       19
        
               { suffix = "ref10";         configureFlags = ["--enable-ref10"]; }

     

       20
       20
        
               { suffix = "donna";         configureFlags = ["--enable-donna"]; }

     

       21
       21
       -
             ] ++ lib.optionals (stdenv.isi686 || stdenv.isx86_64) [

     

       21
       21
       +
             ] ++ lib.optionals stdenv.hostPlatform.isx86 [

     

       22
       22
        
               { suffix = "donna-sse2";    configureFlags = ["--enable-donna-sse2"]; }

     

       23
       23
        
             ] ++ lib.optionals stdenv.isx86_64 [

     

       24
       24
        
               { suffix = "amd64-51-30k";  configureFlags = ["--enable-amd64-51-30k"]; }

+2 -4

pkgs/top-level/all-packages.nix

···

       5159
       5159
        
           icu = icu63;

     

       5160
       5160
        
         };

     

       5161
       5161
        
       

     

       5162
       5162
       -
         fluent-bit = callPackage ../tools/misc/fluent-bit {

     

       5163
       5163
       -
           stdenv = gccStdenv;

     

       5164
       5164
       -
         };

     

       5162
       5162
       +
         fluent-bit = callPackage ../tools/misc/fluent-bit { };

     

       5165
       5163
        
       

     

       5166
       5164
        
         flux = callPackage ../development/compilers/flux { };

     

       5167
       5165
        
       

     
···

       11602
       11600
        
           if ccWrapper.isGNU then ccWrapper.overrideAttrs(old: {

     

       11603
       11601
        
             cc = old.cc.override {

     

       11604
       11602
        
               reproducibleBuild = false;

     

       11605
       11605
       -
               profiledCompiler = with stdenv; (!isDarwin && (isi686 || isx86_64));

     

       11603
       11603
       +
               profiledCompiler = with stdenv; (!isDarwin && hostPlatform.isx86);

     

       11606
       11604
        
             };

     

       11607
       11605
        
           }) else ccWrapper;

     

       11608
       11606