summaryrefslogtreecommitdiff
path: root/gnu/packages
diff options
context:
space:
mode:
Diffstat (limited to 'gnu/packages')
-rw-r--r--gnu/packages/admin.scm10
-rw-r--r--gnu/packages/gnome.scm48
-rw-r--r--gnu/packages/haskell.scm648
-rw-r--r--gnu/packages/package-management.scm7
-rw-r--r--gnu/packages/patches/inetutils-syslogd.patch20
5 files changed, 728 insertions, 5 deletions
diff --git a/gnu/packages/admin.scm b/gnu/packages/admin.scm
index 4d4cef7cf3..3a0361299e 100644
--- a/gnu/packages/admin.scm
+++ b/gnu/packages/admin.scm
@@ -55,7 +55,8 @@
#:use-module (gnu packages libftdi)
#:use-module (gnu packages image)
#:use-module (gnu packages xorg)
- #:use-module (gnu packages python))
+ #:use-module (gnu packages python)
+ #:use-module (gnu packages man))
(define-public dmd
(package
@@ -158,13 +159,18 @@ re-executing them as necessary.")
version ".tar.gz"))
(sha256
(base32
- "04wrm0v7l4890mmbaawd6wjwdv08bkglgqhpz0q4dkb0l50fl8q4"))))
+ "04wrm0v7l4890mmbaawd6wjwdv08bkglgqhpz0q4dkb0l50fl8q4"))
+ (patches (list (search-patch "inetutils-syslogd.patch")))))
(build-system gnu-build-system)
(arguments `(;; FIXME: `tftp.sh' relies on `netstat' from utils-linux,
;; which is currently missing.
#:tests? #f))
(inputs `(("ncurses" ,ncurses)
("readline" ,readline))) ; for 'ftp'
+
+ ;; Help2man is needed because of the patch that modifies syslogd.c.
+ (native-inputs `(("help2man" ,help2man)))
+
(home-page "http://www.gnu.org/software/inetutils/")
(synopsis "Basic networking utilities")
(description
diff --git a/gnu/packages/gnome.scm b/gnu/packages/gnome.scm
index 0c6476387a..ddb8a1f45e 100644
--- a/gnu/packages/gnome.scm
+++ b/gnu/packages/gnome.scm
@@ -1739,6 +1739,54 @@ library.")
and the GLib main loop, to integrate well with GNOME applications.")
(license license:lgpl2.0+)))
+(define-public libsecret
+ (package
+ (name "libsecret")
+ (version "0.18")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "mirror://gnome/sources/libsecret/" version "/"
+ name "-" version ".tar.xz"))
+ (sha256
+ (base32
+ "1qq29c01xxjyx5sl6y5h22w8r0ff4c73bph3gfx3h7mx5mvalwqc"))))
+ (build-system gnu-build-system)
+ (outputs '("out" "doc"))
+ (arguments
+ `(#:tests? #f ; FIXME: Testing hangs.
+ #:make-flags '("CC=gcc") ; for g-ir-scanner.
+ #:configure-flags
+ (list (string-append "--with-html-dir="
+ (assoc-ref %outputs "doc")
+ "/share/gtk-doc/html"))))
+ (native-inputs
+ `(("glib:bin" ,glib "bin") ; for gdbus-codegen, etc.
+ ("gobject-introspection" ,gobject-introspection)
+ ("intltool" ,intltool)
+ ("pkg-config" ,pkg-config)
+ ("vala" ,vala)
+ ("xsltproc" ,libxslt)))
+ ;; These are needed for the tests.
+ ;; FIXME: Add gjs once available.
+ ;("dbus" ,dbus)
+ ;("python2" ,python-2)
+ ;("python2-dbus" ,python2-dbus)
+ ;("python2-pygobject" ,python2-pygobject)
+ ;("python2-pygobject-2" ,python2-pygobject-2)))
+ (propagated-inputs
+ `(("glib" ,glib))) ; required by libsecret-1.pc
+ (inputs
+ `(("docbook-xsl" ,docbook-xsl)
+ ("libgcrypt" ,libgcrypt)
+ ("libxml2" ,libxml2))) ; for XML_CATALOG_FILES
+ (home-page "https://wiki.gnome.org/Projects/Libsecret/")
+ (synopsis "GObject bindings for \"Secret Service\" API")
+ (description
+ "Libsecret is a GObject based library for storing and retrieving passwords
+and other secrets. It communicates with the \"Secret Service\" using DBus.")
+ (license license:lgpl2.1+)))
+
(define-public gnome-mines
(package
(name "gnome-mines")
diff --git a/gnu/packages/haskell.scm b/gnu/packages/haskell.scm
index 05622ca068..e6b8e07be7 100644
--- a/gnu/packages/haskell.scm
+++ b/gnu/packages/haskell.scm
@@ -18,12 +18,14 @@
(define-module (gnu packages haskell)
#:use-module (ice-9 regex)
- #:use-module (guix licenses)
+ #:use-module ((guix licenses) #:select (bsd-3))
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix utils)
#:use-module (guix build-system gnu)
+ #:use-module (guix build-system haskell)
#:use-module (gnu packages perl)
+ #:use-module (gnu packages compression)
#:use-module (gnu packages elf)
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages ghostscript)
@@ -224,4 +226,648 @@
interactive environment for the functional language Haskell.")
(license bsd-3)))
+(define-public ghc-mtl
+ (package
+ (name "ghc-mtl")
+ (version "2.1.3.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/mtl/mtl-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp"))))
+ (build-system haskell-build-system)
+ (home-page "http://github.com/ekmett/mtl")
+ (synopsis
+ "Monad classes, using functional dependencies")
+ (description
+ "Monad classes using functional dependencies, with instances
+for various monad transformers, inspired by the paper
+'Functional Programming with Overloading and Higher-Order Polymorphism',
+by Mark P Jones, in 'Advanced School of Functional Programming', 1995
+http://web.cecs.pdx.edu/~mpj/pubs/springschool.html.")
+ (license bsd-3)))
+
+(define-public ghc-paths
+ (package
+ (name "ghc-paths")
+ (version "0.1.0.9")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/ghc-paths/ghc-paths-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/simonmar/ghc-paths")
+ (synopsis
+ "Knowledge of GHC's installation directories")
+ (description
+ "Knowledge of GHC's installation directories.")
+ (license bsd-3)))
+
+(define-public ghc-zlib
+ (package
+ (name "ghc-zlib")
+ (version "0.5.4.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/zlib/zlib-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm"))))
+ (build-system haskell-build-system)
+ (inputs `(("zlib" ,zlib)))
+ (home-page "http://hackage.haskell.org/package/zlib")
+ (synopsis
+ "Compression and decompression in the gzip and zlib formats")
+ (description
+ "This package provides a pure interface for compressing and decompressing
+streams of data represented as lazy 'ByteString's. It uses the zlib C library
+so it has high performance. It supports the 'zlib', 'gzip' and 'raw'
+compression formats. It provides a convenient high level API suitable for
+most tasks and for the few cases where more control is needed it provides
+access to the full zlib feature set.")
+ (license bsd-3)))
+
+(define-public ghc-stm
+ (package
+ (name "ghc-stm")
+ (version "2.4.4")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/stm/stm-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/stm")
+ (synopsis "Software Transactional Memory")
+ (description
+ "A modular composable concurrency abstraction.")
+ (license bsd-3)))
+
+(define-public ghc-parallel
+ (package
+ (name "ghc-parallel")
+ (version "3.2.0.6")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/parallel/parallel-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/parallel")
+ (synopsis "Parallel programming library")
+ (description
+ "This package provides a library for parallel programming.")
+ (license bsd-3)))
+
+(define-public ghc-text
+ (package
+ (name "ghc-text")
+ (version "1.2.0.4")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/text/text-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page "https://github.com/bos/text")
+ (synopsis
+ "Efficient packed Unicode text type library.")
+ (description
+ "An efficient packed, immutable Unicode text type (both strict and
+lazy), with a powerful loop fusion optimization framework.
+
+The 'Text' type represents Unicode character strings, in a time and
+space-efficient manner. This package provides text processing
+capabilities that are optimized for performance critical use, both
+in terms of large data quantities and high speed.")
+ (license bsd-3)))
+
+(define-public ghc-hashable
+ (package
+ (name "ghc-hashable")
+ (version "1.2.3.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/hashable/hashable-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ ;; these inputs are necessary to use this library
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)))
+ (home-page "http://github.com/tibbe/hashable")
+ (synopsis
+ "Class for types that can be converted to a hash value")
+ (description
+ "This package defines a class, 'Hashable', for types that can be
+converted to a hash value. This class exists for the benefit of hashing-based
+data structures. The package provides instances for basic types and a way to
+combine hash values.")
+ (license bsd-3)))
+
+(define-public ghc-hunit
+ (package
+ (name "ghc-hunit")
+ (version "1.2.5.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/HUnit/HUnit-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a"))))
+ (build-system haskell-build-system)
+ (home-page "http://hunit.sourceforge.net/")
+ (synopsis "Unit testing framework for Haskell")
+ (description
+ "HUnit is a unit testing framework for Haskell, inspired by the
+JUnit tool for Java.")
+ (license bsd-3)))
+
+(define-public ghc-random
+ (package
+ (name "ghc-random")
+ (version "1.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/random/random-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0nis3lbkp8vfx8pkr6v7b7kr5m334bzb0fk9vxqklnp2aw8a865p"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/random")
+ (synopsis "Random number library")
+ (description "This package provides a basic random number generation
+library, including the ability to split random number generators.")
+ (license bsd-3)))
+
+(define-public ghc-primitive
+ (package
+ (name "ghc-primitive")
+ (version "0.5.4.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/primitive/primitive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10"))))
+ (build-system haskell-build-system)
+ (home-page
+ "https://github.com/haskell/primitive")
+ (synopsis "Primitive memory-related operations")
+ (description
+ "This package provides various primitive memory-related operations.")
+ (license bsd-3)))
+
+(define-public ghc-tf-random
+ (package
+ (name "ghc-tf-random")
+ (version "0.5")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/tf-random/tf-random-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f"))))
+ (build-system haskell-build-system)
+ ;; these inputs are necessary to use this package
+ (propagated-inputs
+ `(("ghc-primitive" ,ghc-primitive)
+ ("ghc-random" ,ghc-random)))
+ (home-page "http://hackage.haskell.org/package/tf-random")
+ (synopsis "High-quality splittable pseudorandom number generator")
+ (description "This package contains an implementation of a high-quality
+splittable pseudorandom number generator. The generator is based on a
+cryptographic hash function built on top of the ThreeFish block cipher. See
+the paper \"Splittable Pseudorandom Number Generators Using Cryptographic
+Hashing\" by Claessen, Pałka for details and the rationale of the design.")
+ (license bsd-3)))
+
+(define-public ghc-quickcheck
+ (package
+ (name "ghc-quickcheck")
+ (version "2.8")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/QuickCheck/QuickCheck-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "04xs6mq22bcnkpi616qrbm7jlivh9csnhmvjgp1ifq52an1wr4rx"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:tests? #f ; FIXME: currently missing libraries used for tests.
+ #:configure-flags '("-f base4")))
+ ;; these inputs are necessary to use this package
+ (propagated-inputs
+ `(("ghc-tf-random" ,ghc-tf-random)))
+ (home-page
+ "https://github.com/nick8325/quickcheck")
+ (synopsis
+ "Automatic testing of Haskell programs")
+ (description
+ "QuickCheck is a library for random testing of program properties.")
+ (license bsd-3)))
+
+(define-public ghc-case-insensitive
+ (package
+ (name "ghc-case-insensitive")
+ (version "1.2.0.4")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/case-insensitive/case-insensitive-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ ;; these inputs are necessary to use this library
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-hashable" ,ghc-hashable)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page
+ "https://github.com/basvandijk/case-insensitive")
+ (synopsis "Case insensitive string comparison")
+ (description
+ "The module 'Data.CaseInsensitive' provides the 'CI' type constructor
+which can be parameterised by a string-like type like: 'String', 'ByteString',
+'Text', etc.. Comparisons of values of the resulting type will be insensitive
+to cases.")
+ (license bsd-3)))
+
+(define-public ghc-syb
+ (package
+ (name "ghc-syb")
+ (version "0.4.4")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/syb/syb-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-mtl" ,ghc-mtl)))
+ (home-page
+ "http://www.cs.uu.nl/wiki/GenericProgramming/SYB")
+ (synopsis "Scrap Your Boilerplate")
+ (description
+ "This package contains the generics system described in the
+/Scrap Your Boilerplate/ papers (see
+<http://www.cs.uu.nl/wiki/GenericProgramming/SYB>).
+It defines the 'Data' class of types permitting folding and unfolding
+of constructor applications, instances of this class for primitive
+types, and a variety of traversals.")
+ (license bsd-3)))
+
+(define-public ghc-containers
+ (package
+ (name "ghc-containers")
+ (version "0.5.6.3")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/containers/containers-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1kcd55nl0vzi99i8sr8fmc5j25fv7m0a9hd3nihnq1pd64pfciqn"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page "http://hackage.haskell.org/package/containers")
+ (synopsis "Assorted concrete container types")
+ (description
+ "This package contains efficient general-purpose implementations of
+various basic immutable container types. The declared cost of each operation
+is either worst-case or amortized, but remains valid even if structures are
+shared.")
+ (license bsd-3)))
+
+(define-public ghc-fgl
+ (package
+ (name "ghc-fgl")
+ (version "5.5.1.0")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/fgl/fgl-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-mtl" ,ghc-mtl)))
+ (home-page "http://web.engr.oregonstate.edu/~erwig/fgl/haskell")
+ (synopsis
+ "Martin Erwig's Functional Graph Library")
+ (description "The functional graph library, FGL, is a collection of type
+and function definitions to address graph problems. The basis of the library
+is an inductive definition of graphs in the style of algebraic data types that
+encourages inductive, recursive definitions of graph algorithms.")
+ (license bsd-3)))
+
+(define-public ghc-unordered-containers
+ (package
+ (name "ghc-unordered-containers")
+ (version "0.2.5.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/unordered-containers/unordered-containers-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ ;; these inputs are necessary to use this library
+ (propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page
+ "https://github.com/tibbe/unordered-containers")
+ (synopsis
+ "Efficient hashing-based container types")
+ (description
+ "Efficient hashing-based container types. The containers have been
+optimized for performance critical use, both in terms of large data quantities
+and high speed.")
+ (license bsd-3)))
+
+(define-public ghc-split
+ (package
+ (name "ghc-split")
+ (version "0.2.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/split/split-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://hackage.haskell.org/package/split")
+ (synopsis
+ "Combinator library for splitting lists")
+ (description "A collection of various methods for splitting lists into
+parts, akin to the 'split' function found in several mainstream languages.")
+ (license bsd-3)))
+
+(define-public ghc-parsec
+ (package
+ (name "ghc-parsec")
+ (version "3.1.9")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/parsec/parsec-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "1ja20cmj6v336jy87c6h3jzjp00sdbakwbdwp11iln499k913xvi"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ ;; these inputs are necessary to use this library
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-mtl" ,ghc-mtl)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page
+ "https://github.com/aslatter/parsec")
+ (synopsis "Monadic parser combinators")
+ (description "Parsec is a parser library. It is simple, safe, well
+documented, has extensive libraries, good error messages, and is fast. It is
+defined as a monad transformer that can be stacked on arbitrary monads, and it
+is also parametric in the input stream type.")
+ (license bsd-3)))
+
+(define-public ghc-vector
+ (package
+ (name "ghc-vector")
+ (version "0.10.12.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/vector/vector-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)))
+ ;; these inputs are necessary to use this library
+ (propagated-inputs
+ `(("ghc-primitive" ,ghc-primitive)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page "https://github.com/haskell/vector")
+ (synopsis "Efficient Arrays")
+ (description "An efficient implementation of Int-indexed arrays (both
+mutable and immutable), with a powerful loop optimisation framework.")
+ (license bsd-3)))
+
+(define-public ghc-network
+ (package
+ (name "ghc-network")
+ (version "2.6.0.2")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/network/network-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (arguments
+ `(#:tests? #f ; FIXME: currently missing libraries used for tests.
+ #:phases
+ (modify-phases %standard-phases
+ (add-before configure set-sh
+ (lambda _ (setenv "CONFIG_SHELL" "sh"))))))
+ (home-page "https://github.com/haskell/network")
+ (synopsis "Low-level networking interface")
+ (description
+ "This package provides a low-level networking interface.")
+ (license bsd-3)))
+
+(define-public ghc-network-uri
+ (package
+ (name "ghc-network-uri")
+ (version "2.6.0.1")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/network-uri/network-uri-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-network" ,ghc-network)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (propagated-inputs
+ `(("ghc-parsec" ,ghc-parsec)))
+ (home-page
+ "https://github.com/haskell/network-uri")
+ (synopsis "Labrary for URI manipulation")
+ (description "This package provides an URI manipulation inteface. In
+'network-2.6' the 'Network.URI' module was split off from the 'network'
+package into this package.")
+ (license bsd-3)))
+
+(define-public ghc-http
+ (package
+ (name "ghc-http")
+ (version "4000.2.19")
+ (outputs '("out" "doc"))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/HTTP/HTTP-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (propagated-inputs
+ `(("ghc-parsec" ,ghc-parsec)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-network" ,ghc-network)
+ ("ghc-network-uri" ,ghc-network-uri)))
+ (arguments
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
+ (home-page "https://github.com/haskell/HTTP")
+ (synopsis "Library for client-side HTTP")
+ (description
+ "The HTTP package supports client-side web programming in Haskell. It
+lets you set up HTTP connections, transmitting requests and processing the
+responses coming back.")
+ (license bsd-3)))
+
;;; haskell.scm ends here
diff --git a/gnu/packages/package-management.scm b/gnu/packages/package-management.scm
index f31f872602..9512fcd3b5 100644
--- a/gnu/packages/package-management.scm
+++ b/gnu/packages/package-management.scm
@@ -142,7 +142,10 @@ the Nix package manager.")
(define guix-devel
;; Development version of Guix.
- (let ((commit "9586011"))
+ ;;
+ ;; Note: use a short commit id; when using the long one, the limit on socket
+ ;; file names is exceeded while running the tests.
+ (let ((commit "0b13161"))
(package (inherit guix-0.8.1)
(version (string-append "0.8.1." commit))
(source (origin
@@ -152,7 +155,7 @@ the Nix package manager.")
(commit commit)))
(sha256
(base32
- "0dcmw8gz2qxknjnh9k8rdwmgysnxnvawdmlg1pyzngakwlsy1c3z"))))
+ "0h9yyfxs14di858hb9ypjvdjryv8nzll6f9vxkggcy40iyhp65sh"))))
(arguments
(substitute-keyword-arguments (package-arguments guix-0.8.1)
((#:phases phases)
diff --git a/gnu/packages/patches/inetutils-syslogd.patch b/gnu/packages/patches/inetutils-syslogd.patch
new file mode 100644
index 0000000000..0bf9eb7fc6
--- /dev/null
+++ b/gnu/packages/patches/inetutils-syslogd.patch
@@ -0,0 +1,20 @@
+From <http://lists.gnu.org/archive/html/bug-inetutils/2015-04/msg00001.html>.
+
+2015-04-01 Ludovic Courtès <ludo@gnu.org>
+
+ * src/syslogd.c (load_conffile): Use 'bcopy' instead of 'strcpy'
+ since the two regions may overlap.
+ Reported by Alex Kost <alezost@gmail.com>
+ at <http://lists.gnu.org/archive/html/guix-devel/2015-03/msg00780.html>.
+
+--- a/src/syslogd.c
++++ b/src/syslogd.c
+@@ -1989,7 +1989,7 @@ load_conffile (const char *filename, struct filed **nextp)
+ if (*p == '\0' || *p == '#')
+ continue;
+
+- strcpy (cline, p);
++ bcopy (p, cline, strlen (p) + 1);
+
+ /* Cut the trailing spaces. */
+ for (p = strchr (cline, '\0'); isspace (*--p);)
generated by cgit v1.2.3 (git 2.44.0) at 2024-07-03 11:16:14 +0000