Fri Jan 3 03:17:00 UTC 2014

26 files changed, 2266 insertions, 121 deletions

diff --git a/community/acpi/PKGBUILD b/community/acpi/PKGBUILD
index 634c26b0f..564505917 100644
--- a/community/acpi/PKGBUILD
+++ b/community/acpi/PKGBUILD
@@ -1,24 +1,27 @@
-# $Id: PKGBUILD 148027 2012-01-30 03:41:28Z dan $
+# $Id: PKGBUILD 103278 2014-01-02 12:22:39Z arodseth $
+# Maintainer: Alexander Rødseth <rodseth@gmail.com>
 # Contributor: Judd Vinet <jvinet@zeroflux.org>
 
 pkgname=acpi
-pkgver=1.6
+pkgver=1.7
 pkgrel=1
-pkgdesc="Linux ACPI client providing battery, AC power, and thermal readings"
-arch=('i686' 'x86_64')
-url="http://sourceforge.net/projects/acpiclient"
-depends=('glibc')
-source=(http://downloads.sourceforge.net/acpiclient/$pkgname-$pkgver.tar.gz)
+pkgdesc='Client for battery, power, and thermal readings'
+arch=('x86_64' 'i686')
+url='http://sourceforge.net/projects/acpiclient/'
 license=('GPL2')
-sha256sums=('ed61d20400c4fd3965dde9b49ab3ac74da02f8eca1a55454f7a1ac3fa1fd5c31')
+depends=('glibc')
+source=("http://downloads.sourceforge.net/acpiclient/$pkgname-$pkgver.tar.gz")
+sha256sums=('d7a504b61c716ae5b7e81a0c67a50a51f06c7326f197b66a4b823de076a35005')
 
 build() {
-  cd $srcdir/$pkgname-$pkgver
+  cd "$pkgname-$pkgver"
+
   ./configure --prefix=/usr
   make
 }
 
 package() {
-  cd $srcdir/$pkgname-$pkgver
-  make DESTDIR=$pkgdir install
+  make -C "$pkgname-$pkgver" DESTDIR"=$pkgdir" install
 }
+
+# vim:set ts=2 sw=2 et:
diff --git a/community/busybox/PKGBUILD b/community/busybox/PKGBUILD
index 99a1f8681..1e565d1f8 100644
--- a/community/busybox/PKGBUILD
+++ b/community/busybox/PKGBUILD
@@ -1,20 +1,20 @@
-# $Id: PKGBUILD 93409 2013-07-03 10:50:24Z spupykin $
+# $Id: PKGBUILD 103299 2014-01-02 22:41:35Z spupykin $
 # Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
 # Contributor: Jens Pranaitis <jens@jenux.homelinux.org>
 
 pkgname=busybox
-pkgver=1.21.1
+pkgver=1.22.0
 pkgrel=1
 pkgdesc="Utilities for rescue and embedded systems"
 arch=("i686" "x86_64")
 url="http://www.busybox.net"
 license=('GPL')
-makedepends=("make" "gcc" "sed" "ncurses")
+makedepends=("make" "gcc" "sed" "ncurses" "glibc-static")
 source=($url/downloads/$pkgname-$pkgver.tar.bz2
 	config)
 install=busybox.install
-md5sums=('795394f83903b5eec6567d51eebb417e'
-         '3fbd88dc6327ff0455c17409efdbab79')
+md5sums=('ac1881d1cdeb0729b22c663feaf1c663'
+         'e7c697e37b2120f0e0a354c48180cde4')
 
 build() {
   cd "$srcdir/$pkgname-$pkgver"
diff --git a/community/busybox/config b/community/busybox/config
index b89c59b12..276cf9f63 100644
--- a/community/busybox/config
+++ b/community/busybox/config
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Busybox version: 1.21.1
-# Wed Jul  3 14:35:32 2013
+# Busybox version: 1.22.0
+# Fri Jan  3 01:07:04 2014
 #
 CONFIG_HAVE_DOT_CONFIG=y
 
@@ -135,7 +135,14 @@ CONFIG_FEATURE_SEAMLESS_Z=y
 CONFIG_AR=y
 CONFIG_FEATURE_AR_LONG_FILENAMES=y
 CONFIG_FEATURE_AR_CREATE=y
+CONFIG_UNCOMPRESS=y
+CONFIG_GUNZIP=y
 CONFIG_BUNZIP2=y
+CONFIG_UNLZMA=y
+CONFIG_FEATURE_LZMA_FAST=y
+CONFIG_LZMA=y
+CONFIG_UNXZ=y
+CONFIG_XZ=y
 CONFIG_BZIP2=y
 CONFIG_CPIO=y
 CONFIG_FEATURE_CPIO_O=y
@@ -143,7 +150,6 @@ CONFIG_FEATURE_CPIO_O=y
 # CONFIG_DPKG is not set
 # CONFIG_DPKG_DEB is not set
 # CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY is not set
-CONFIG_GUNZIP=y
 CONFIG_GZIP=y
 # CONFIG_FEATURE_GZIP_LONG_OPTIONS is not set
 CONFIG_GZIP_FAST=0
@@ -163,12 +169,6 @@ CONFIG_FEATURE_TAR_TO_COMMAND=y
 CONFIG_FEATURE_TAR_UNAME_GNAME=y
 # CONFIG_FEATURE_TAR_NOPRESERVE_TIME is not set
 # CONFIG_FEATURE_TAR_SELINUX is not set
-CONFIG_UNCOMPRESS=y
-CONFIG_UNLZMA=y
-CONFIG_FEATURE_LZMA_FAST=y
-CONFIG_LZMA=y
-CONFIG_UNXZ=y
-CONFIG_XZ=y
 CONFIG_UNZIP=y
 
 #
@@ -186,6 +186,7 @@ CONFIG_GROUPS=y
 CONFIG_TEST=y
 CONFIG_FEATURE_TEST_64=y
 CONFIG_TOUCH=y
+CONFIG_FEATURE_TOUCH_NODEREF=y
 CONFIG_FEATURE_TOUCH_SUSV3=y
 CONFIG_TR=y
 CONFIG_FEATURE_TR_CLASSES=y
@@ -363,7 +364,16 @@ CONFIG_WHICH=y
 #
 # Editors
 #
+CONFIG_AWK=y
+# CONFIG_FEATURE_AWK_LIBM is not set
+CONFIG_FEATURE_AWK_GNU_EXTENSIONS=y
+CONFIG_CMP=y
+CONFIG_DIFF=y
+# CONFIG_FEATURE_DIFF_LONG_OPTIONS is not set
+CONFIG_FEATURE_DIFF_DIR=y
+CONFIG_ED=y
 CONFIG_PATCH=y
+CONFIG_SED=y
 CONFIG_VI=y
 CONFIG_FEATURE_VI_MAX_LEN=4096
 # CONFIG_FEATURE_VI_8BIT is not set
@@ -378,14 +388,6 @@ CONFIG_FEATURE_VI_SETOPTS=y
 CONFIG_FEATURE_VI_SET=y
 CONFIG_FEATURE_VI_WIN_RESIZE=y
 CONFIG_FEATURE_VI_ASK_TERMINAL=y
-CONFIG_AWK=y
-# CONFIG_FEATURE_AWK_LIBM is not set
-CONFIG_CMP=y
-CONFIG_DIFF=y
-# CONFIG_FEATURE_DIFF_LONG_OPTIONS is not set
-CONFIG_FEATURE_DIFF_DIR=y
-CONFIG_ED=y
-CONFIG_SED=y
 CONFIG_FEATURE_ALLOW_EXEC=y
 
 #
@@ -528,6 +530,7 @@ CONFIG_DEFAULT_DEPMOD_FILE="modules.dep"
 # Linux System Utilities
 #
 CONFIG_BLOCKDEV=y
+CONFIG_FSTRIM=y
 CONFIG_MDEV=y
 CONFIG_FEATURE_MDEV_CONF=y
 CONFIG_FEATURE_MDEV_RENAME=y
@@ -614,26 +617,27 @@ CONFIG_VOLUMEID=y
 #
 # Filesystem/Volume identification
 #
-CONFIG_FEATURE_VOLUMEID_EXT=y
 CONFIG_FEATURE_VOLUMEID_BTRFS=y
-CONFIG_FEATURE_VOLUMEID_REISERFS=y
-CONFIG_FEATURE_VOLUMEID_FAT=y
+CONFIG_FEATURE_VOLUMEID_CRAMFS=y
 CONFIG_FEATURE_VOLUMEID_EXFAT=y
+CONFIG_FEATURE_VOLUMEID_EXT=y
+CONFIG_FEATURE_VOLUMEID_F2FS=y
+CONFIG_FEATURE_VOLUMEID_FAT=y
 CONFIG_FEATURE_VOLUMEID_HFS=y
+CONFIG_FEATURE_VOLUMEID_ISO9660=y
 CONFIG_FEATURE_VOLUMEID_JFS=y
-CONFIG_FEATURE_VOLUMEID_XFS=y
+CONFIG_FEATURE_VOLUMEID_LINUXRAID=y
+CONFIG_FEATURE_VOLUMEID_LINUXSWAP=y
+CONFIG_FEATURE_VOLUMEID_LUKS=y
 CONFIG_FEATURE_VOLUMEID_NILFS=y
 CONFIG_FEATURE_VOLUMEID_NTFS=y
-CONFIG_FEATURE_VOLUMEID_ISO9660=y
-CONFIG_FEATURE_VOLUMEID_UDF=y
-CONFIG_FEATURE_VOLUMEID_LUKS=y
-CONFIG_FEATURE_VOLUMEID_LINUXSWAP=y
-CONFIG_FEATURE_VOLUMEID_CRAMFS=y
+CONFIG_FEATURE_VOLUMEID_OCFS2=y
+CONFIG_FEATURE_VOLUMEID_REISERFS=y
 CONFIG_FEATURE_VOLUMEID_ROMFS=y
 CONFIG_FEATURE_VOLUMEID_SQUASHFS=y
 CONFIG_FEATURE_VOLUMEID_SYSV=y
-CONFIG_FEATURE_VOLUMEID_OCFS2=y
-CONFIG_FEATURE_VOLUMEID_LINUXRAID=y
+CONFIG_FEATURE_VOLUMEID_UDF=y
+CONFIG_FEATURE_VOLUMEID_XFS=y
 
 #
 # Miscellaneous Utilities
@@ -651,6 +655,7 @@ CONFIG_FEATURE_LESS_REGEXP=y
 # CONFIG_FEATURE_LESS_LINENUMS is not set
 # CONFIG_NANDWRITE is not set
 # CONFIG_NANDDUMP is not set
+CONFIG_RFKILL=y
 CONFIG_SETSERIAL=y
 # CONFIG_UBIATTACH is not set
 # CONFIG_UBIDETACH is not set
@@ -658,6 +663,7 @@ CONFIG_UBIMKVOL=y
 CONFIG_UBIRMVOL=y
 CONFIG_UBIRSVOL=y
 CONFIG_UBIUPDATEVOL=y
+CONFIG_WALL=y
 CONFIG_ADJTIMEX=y
 # CONFIG_BBCONFIG is not set
 # CONFIG_FEATURE_COMPRESS_BBCONFIG is not set
@@ -714,7 +720,6 @@ CONFIG_MOUNTPOINT=y
 CONFIG_MT=y
 CONFIG_RAIDAUTORUN=y
 CONFIG_READAHEAD=y
-CONFIG_RFKILL=y
 CONFIG_RUNLEVEL=y
 CONFIG_RX=y
 CONFIG_SETSID=y
@@ -725,7 +730,6 @@ CONFIG_TIME=y
 CONFIG_TIMEOUT=y
 CONFIG_TTYSIZE=y
 CONFIG_VOLNAME=y
-CONFIG_WALL=y
 CONFIG_WATCHDOG=y
 
 #
diff --git a/community/flickcurl/PKGBUILD b/community/flickcurl/PKGBUILD
index 6c0cd5ab6..25b1ae489 100644
--- a/community/flickcurl/PKGBUILD
+++ b/community/flickcurl/PKGBUILD
@@ -1,16 +1,16 @@
-# $Id: PKGBUILD 100106 2013-11-01 17:15:29Z spupykin $
+# $Id: PKGBUILD 103303 2014-01-02 22:42:11Z spupykin $
 # Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
 
 pkgname=flickcurl
-pkgver=1.24
-pkgrel=2
+pkgver=1.25
+pkgrel=1
 pkgdesc="C library for the Flickr API"
 arch=(i686 x86_64)
 url="http://librdf.org/flickcurl/"
 license=('GPL')
 depends=('raptor' 'curl')
 source=(http://download.dajobe.org/flickcurl/flickcurl-$pkgver.tar.gz)
-md5sums=('7cf6a627465471d76a5f4dc31099d9cf')
+md5sums=('9598526f2b9a0a4619d1f1563300e72a')
 
 build() {
   cd "$srcdir/$pkgname-$pkgver"
diff --git a/community/glibc-static/PKGBUILD b/community/glibc-static/PKGBUILD
new file mode 100644
index 000000000..cff060a60
--- /dev/null
+++ b/community/glibc-static/PKGBUILD
@@ -0,0 +1,122 @@
+# $Id: PKGBUILD 197798 2013-10-30 10:37:54Z allan $
+# Maintainer: Allan McRae <allan@archlinux.org>
+
+# toolchain build order: linux-api-headers->glibc->binutils->gcc->binutils->glibc
+# NOTE: valgrind requires rebuilt with each major glibc version
+
+# NOTE: adjust version in install script when locale files are updated
+
+pkgname=glibc-static
+pkgver=2.18
+pkgrel=1
+pkgdesc="GNU C Library"
+arch=('i686' 'x86_64')
+url="http://www.gnu.org/software/libc"
+license=('GPL' 'LGPL')
+groups=('base')
+depends=('linux-api-headers>=3.7' 'tzdata' 'filesystem>=2013.01')
+makedepends=('gcc>=4.7')
+options=('!strip' 'staticlibs')
+source=(http://ftp.gnu.org/gnu/libc/glibc-${pkgver}.tar.xz{,.sig}
+        glibc-2.18-make-4.patch
+        glibc-2.18-readdir_r-CVE-2013-4237.patch
+        glibc-2.18-malloc-corrupt-CVE-2013-4332.patch
+        glibc-2.18-strcoll-CVE-2012-4412+4424.patch
+        glibc-2.18-ptr-mangle-CVE-2013-4788.patch
+        glibc-2.18-getaddrinfo-CVE-2013-4458.patch
+        glibc-2.18-getaddrinfo-assertion.patch
+        glibc-2.18-strstr-hackfix.patch)
+md5sums=('88fbbceafee809e82efd52efa1e3c58f'
+         'SKIP'
+         'e1883c2d1b01ff73650db5f5bb5a5a52'
+         '154da6bf5a5248f42a7bf5bf08e01a47'
+         'b79561ab9dce900e9bbeaf0d49927c2b'
+         'c7264b99d0f7e51922a4d3126182c40a'
+         '9749ba386b08a8fe53e7ecede9bf2dfb'
+         '71329fccb8eb583fb0d67b55f1e8df68'
+         'd4d86add33f22125777e0ecff06bc9bb'
+         '4441f6dfe7d75ced1fa75e54dd21d36e')
+
+prepare() {
+  cd ${srcdir}/glibc-${pkgver}
+
+  # compatibility with make-4.0 (submitted upstream)
+  patch -p1 -i $srcdir/glibc-2.18-make-4.patch
+
+  # upstream commit 91ce4085
+  patch -p1 -i $srcdir/glibc-2.18-readdir_r-CVE-2013-4237.patch
+
+  # upstream commits 1159a193, 55e17aad and b73ed247
+  patch -p1 -i $srcdir/glibc-2.18-malloc-corrupt-CVE-2013-4332.patch
+
+  # upstream commits 1326ba1a, 141f3a77 and 303e567a
+  patch -p1 -i $srcdir/glibc-2.18-strcoll-CVE-2012-4412+4424.patch
+
+  # upstream commits c61b4d41 and 0b1f8e35
+  patch -p1 -i $srcdir/glibc-2.18-ptr-mangle-CVE-2013-4788.patch
+
+  # upstream commit 7cbcdb36
+  patch -p1 -i $srcdir/glibc-2.18-getaddrinfo-CVE-2013-4458.patch
+
+  # upstream commit 894f3f10
+  patch -p1 -i $srcdir/glibc-2.18-getaddrinfo-assertion.patch
+
+  # hack fix for strstr issues on x86
+  patch -p1 -i $srcdir/glibc-2.18-strstr-hackfix.patch
+
+  mkdir ${srcdir}/glibc-build
+}
+
+build() {
+  cd ${srcdir}/glibc-build
+
+  if [[ ${CARCH} = "i686" ]]; then
+    # Hack to fix NPTL issues with Xen, only required on 32bit platforms
+    # TODO: make separate glibc-xen package for i686
+    export CFLAGS="${CFLAGS} -mno-tls-direct-seg-refs"
+  fi
+
+  echo "slibdir=/usr/lib" >> configparms
+  echo "sbindir=/usr/bin" >> configparms
+  echo "rootsbindir=/usr/bin" >> configparms
+
+  # remove hardening options for building libraries
+  CFLAGS=${CFLAGS/-fstack-protector/}
+  CPPFLAGS=${CPPFLAGS/-D_FORTIFY_SOURCE=2/}
+
+  ${srcdir}/glibc-${pkgver}/configure --prefix=/usr \
+      --libdir=/usr/lib --libexecdir=/usr/lib \
+      --with-headers=/usr/include \
+      --with-bugurl=https://bugs.archlinux.org/ \
+      --enable-add-ons=nptl,libidn \
+      --enable-obsolete-rpc \
+      --enable-kernel=2.6.32 \
+      --enable-bind-now --disable-profile \
+      --enable-stackguard-randomization \
+      --enable-lock-elision \
+      --enable-multi-arch
+
+  # build libraries with hardening disabled
+  echo "build-programs=no" >> configparms
+  make
+
+  # re-enable hardening for programs
+  sed -i "/build-programs=/s#no#yes#" configparms
+  echo "CC += -fstack-protector -D_FORTIFY_SOURCE=2" >> configparms
+  echo "CXX += -fstack-protector -D_FORTIFY_SOURCE=2" >> configparms
+  make
+
+  # remove harding in preparation to run test-suite
+  sed -i '4,6d' configparms
+}
+
+package() {
+  cd ${srcdir}/glibc-build
+  make install_root=${pkgdir} install
+  rm -rf $pkgdir/usr/{bin,include,share,lib/{pkgconfig,audit,gconv,getconf}}
+  rm -rf $pkgdir/{etc,var}
+  rm -f $pkgdir/usr/lib/*.so*
+  rm -f $pkgdir/usr/lib/*.o
+  rm -f $pkgdir/usr/lib/lib{bsd-compat,c,c_nonshared,dl,g,ieee,m,mcheck,pthread,pthread_nonshared,rpcsvc}.a
+  strip $STRIP_STATIC $pkgdir/usr/lib/*.a
+}
diff --git a/community/glibc-static/glibc-2.18-getaddrinfo-CVE-2013-4458.patch b/community/glibc-static/glibc-2.18-getaddrinfo-CVE-2013-4458.patch
new file mode 100644
index 000000000..a7bc67c6f
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-getaddrinfo-CVE-2013-4458.patch
@@ -0,0 +1,41 @@
+diff --git a/sysdeps/posix/getaddrinfo.c b/sysdeps/posix/getaddrinfo.c
+index e6ce4cf..8ff74b4 100644
+--- a/sysdeps/posix/getaddrinfo.c
++++ b/sysdeps/posix/getaddrinfo.c
+@@ -197,7 +197,22 @@ gaih_inet_serv (const char *servicename, const struct gaih_typeproto *tp,
+ 				&rc, &herrno, NULL, &localcanon));	      \
+     if (rc != ERANGE || herrno != NETDB_INTERNAL)			      \
+       break;								      \
+-    tmpbuf = extend_alloca (tmpbuf, tmpbuflen, 2 * tmpbuflen);		      \
++    if (!malloc_tmpbuf && __libc_use_alloca (alloca_used + 2 * tmpbuflen))    \
++      tmpbuf = extend_alloca_account (tmpbuf, tmpbuflen, 2 * tmpbuflen,	      \
++				      alloca_used);			      \
++    else								      \
++      {									      \
++	char *newp = realloc (malloc_tmpbuf ? tmpbuf : NULL,		      \
++			      2 * tmpbuflen);				      \
++	if (newp == NULL)						      \
++	  {								      \
++	    result = -EAI_MEMORY;					      \
++	    goto free_and_return;					      \
++	  }								      \
++	tmpbuf = newp;							      \
++	malloc_tmpbuf = true;						      \
++	tmpbuflen = 2 * tmpbuflen;					      \
++      }									      \
+   }									      \
+   if (status == NSS_STATUS_SUCCESS && rc == 0)				      \
+     h = &th;								      \
+@@ -209,7 +224,8 @@ gaih_inet_serv (const char *servicename, const struct gaih_typeproto *tp,
+ 	{								      \
+ 	  __set_h_errno (herrno);					      \
+ 	  _res.options |= old_res_options & RES_USE_INET6;		      \
+-	  return -EAI_SYSTEM;						      \
++	  result = -EAI_SYSTEM;						      \
++	  goto free_and_return;						      \
+ 	}								      \
+       if (herrno == TRY_AGAIN)						      \
+ 	no_data = EAI_AGAIN;						      \
+-- 
+1.8.4.1
+
diff --git a/community/glibc-static/glibc-2.18-getaddrinfo-assertion.patch b/community/glibc-static/glibc-2.18-getaddrinfo-assertion.patch
new file mode 100644
index 000000000..2f1f7c694
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-getaddrinfo-assertion.patch
@@ -0,0 +1,39 @@
+diff --git a/sysdeps/posix/getaddrinfo.c b/sysdeps/posix/getaddrinfo.c
+index 0f4b885..e6ce4cf 100644
+--- a/sysdeps/posix/getaddrinfo.c
++++ b/sysdeps/posix/getaddrinfo.c
+@@ -1666,13 +1666,13 @@ rfc3484_sort (const void *p1, const void *p2, void *arg)
+ 
+ 	      /* Fill in the results in all the records.  */
+ 	      for (int i = 0; i < src->nresults; ++i)
+-		if (src->results[i].index == a1_index)
++		if (a1_index != -1 && src->results[i].index == a1_index)
+ 		  {
+ 		    assert (src->results[i].native == -1
+ 			    || src->results[i].native == a1_native);
+ 		    src->results[i].native = a1_native;
+ 		  }
+-		else if (src->results[i].index == a2_index)
++		else if (a2_index != -1 && src->results[i].index == a2_index)
+ 		  {
+ 		    assert (src->results[i].native == -1
+ 			    || src->results[i].native == a2_native);
+@@ -2532,7 +2532,14 @@ getaddrinfo (const char *name, const char *service,
+ 			  tmp.addr[0] = 0;
+ 			  tmp.addr[1] = 0;
+ 			  tmp.addr[2] = htonl (0xffff);
+-			  tmp.addr[3] = sinp->sin_addr.s_addr;
++			  /* Special case for lo interface, the source address
++			     being possibly different than the interface
++			     address. */
++			  if ((ntohl(sinp->sin_addr.s_addr) & 0xff000000)
++			      == 0x7f000000)
++			    tmp.addr[3] = htonl(0x7f000001);
++			  else
++			    tmp.addr[3] = sinp->sin_addr.s_addr;
+ 			}
+ 		      else
+ 			{
+-- 
+1.8.4.1
+
diff --git a/community/glibc-static/glibc-2.18-make-4.patch b/community/glibc-static/glibc-2.18-make-4.patch
new file mode 100644
index 000000000..374933464
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-make-4.patch
@@ -0,0 +1,45 @@
+From dc76f0c32dae689a08aa21a1d206d4cd62adb278 Mon Sep 17 00:00:00 2001
+From: Marc-Antoine Perennou <Marc-Antoine@Perennou.com>
+Date: Thu, 10 Oct 2013 14:26:12 +0900
+Subject: [PATCH] configure: allow building with GNU Make 4
+
+Currently, configure errors telling make 4 is too old
+since it does not match our regexp.
+
+configure.in: allow GNU Make 4.*
+
+Signed-off-by: Marc-Antoine Perennou <Marc-Antoine@Perennou.com>
+---
+ configure    | 2 +-
+ configure.in | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/configure b/configure
+index 5e2f4d0..e139bf0 100755
+--- a/configure
++++ b/configure
+@@ -4761,7 +4761,7 @@ $as_echo_n "checking version of $MAKE... " >&6; }
+   ac_prog_version=`$MAKE --version 2>&1 | sed -n 's/^.*GNU Make[^0-9]*\([0-9][0-9.]*\).*$/\1/p'`
+   case $ac_prog_version in
+     '') ac_prog_version="v. ?.??, bad"; ac_verc_fail=yes;;
+-    3.79* | 3.[89]*)
++    3.79* | 3.[89]* | 4.*)
+        ac_prog_version="$ac_prog_version, ok"; ac_verc_fail=no;;
+     *) ac_prog_version="$ac_prog_version, bad"; ac_verc_fail=yes;;
+ 
+diff --git a/configure.in b/configure.in
+index a7f9881..95c36b6 100644
+--- a/configure.in
++++ b/configure.in
+@@ -984,7 +984,7 @@ AC_CHECK_PROG_VER(CC, ${ac_tool_prefix}gcc ${ac_tool_prefix}cc, -v,
+   critic_missing="$critic_missing gcc")
+ AC_CHECK_PROG_VER(MAKE, gnumake gmake make, --version,
+   [GNU Make[^0-9]*\([0-9][0-9.]*\)],
+-  [3.79* | 3.[89]*], critic_missing="$critic_missing make")
++  [3.79* | 3.[89]* | 4.*], critic_missing="$critic_missing make")
+ 
+ AC_CHECK_PROG_VER(MSGFMT, gnumsgfmt gmsgfmt msgfmt, --version,
+   [GNU gettext.* \([0-9]*\.[0-9.]*\)],
+-- 
+1.8.4.1
+
diff --git a/community/glibc-static/glibc-2.18-malloc-corrupt-CVE-2013-4332.patch b/community/glibc-static/glibc-2.18-malloc-corrupt-CVE-2013-4332.patch
new file mode 100644
index 000000000..093db86c9
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-malloc-corrupt-CVE-2013-4332.patch
@@ -0,0 +1,54 @@
+diff --git a/malloc/malloc.c b/malloc/malloc.c
+index dd295f5..7f43ba3 100644
+--- a/malloc/malloc.c
++++ b/malloc/malloc.c
+@@ -3082,6 +3082,13 @@ __libc_pvalloc(size_t bytes)
+   size_t page_mask = GLRO(dl_pagesize) - 1;
+   size_t rounded_bytes = (bytes + page_mask) & ~(page_mask);
+ 
++  /* Check for overflow.  */
++  if (bytes > SIZE_MAX - 2*pagesz - MINSIZE)
++    {
++      __set_errno (ENOMEM);
++      return 0;
++    }
++
+   void *(*hook) (size_t, size_t, const void *) =
+     force_reg (__memalign_hook);
+   if (__builtin_expect (hook != NULL, 0))
+diff --git a/malloc/malloc.c b/malloc/malloc.c
+index 7f43ba3..3148c5f 100644
+--- a/malloc/malloc.c
++++ b/malloc/malloc.c
+@@ -3046,6 +3046,13 @@ __libc_valloc(size_t bytes)
+ 
+   size_t pagesz = GLRO(dl_pagesize);
+ 
++  /* Check for overflow.  */
++  if (bytes > SIZE_MAX - pagesz - MINSIZE)
++    {
++      __set_errno (ENOMEM);
++      return 0;
++    }
++
+   void *(*hook) (size_t, size_t, const void *) =
+     force_reg (__memalign_hook);
+   if (__builtin_expect (hook != NULL, 0))
+diff --git a/malloc/malloc.c b/malloc/malloc.c
+index 3148c5f..f7718a9 100644
+--- a/malloc/malloc.c
++++ b/malloc/malloc.c
+@@ -3015,6 +3015,13 @@ __libc_memalign(size_t alignment, size_t bytes)
+   /* Otherwise, ensure that it is at least a minimum chunk size */
+   if (alignment <  MINSIZE) alignment = MINSIZE;
+ 
++  /* Check for overflow.  */
++  if (bytes > SIZE_MAX - alignment - MINSIZE)
++    {
++      __set_errno (ENOMEM);
++      return 0;
++    }
++
+   arena_get(ar_ptr, bytes + alignment + MINSIZE);
+   if(!ar_ptr)
+     return 0;
diff --git a/community/glibc-static/glibc-2.18-ptr-mangle-CVE-2013-4788.patch b/community/glibc-static/glibc-2.18-ptr-mangle-CVE-2013-4788.patch
new file mode 100644
index 000000000..09a439440
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-ptr-mangle-CVE-2013-4788.patch
@@ -0,0 +1,485 @@
+diff --git a/csu/libc-start.c b/csu/libc-start.c
+index e5da3ef..c898d06 100644
+--- a/csu/libc-start.c
++++ b/csu/libc-start.c
+@@ -37,6 +37,12 @@ extern void __pthread_initialize_minimal (void);
+    in thread local area.  */
+ uintptr_t __stack_chk_guard attribute_relro;
+ # endif
++# ifndef  THREAD_SET_POINTER_GUARD
++/* Only exported for architectures that don't store the pointer guard
++   value in thread local area.  */
++uintptr_t __pointer_chk_guard_local
++	attribute_relro attribute_hidden __attribute__ ((nocommon));
++# endif
+ #endif
+ 
+ #ifdef HAVE_PTR_NTHREADS
+@@ -195,6 +201,16 @@ LIBC_START_MAIN (int (*main) (int, char **, char ** MAIN_AUXVEC_DECL),
+ # else
+   __stack_chk_guard = stack_chk_guard;
+ # endif
++
++  /* Set up the pointer guard value.  */
++  uintptr_t pointer_chk_guard = _dl_setup_pointer_guard (_dl_random,
++							 stack_chk_guard);
++# ifdef THREAD_SET_POINTER_GUARD
++  THREAD_SET_POINTER_GUARD (pointer_chk_guard);
++# else
++  __pointer_chk_guard_local = pointer_chk_guard;
++# endif
++
+ #endif
+ 
+   /* Register the destructor of the dynamic linker if there is any.  */
+diff --git a/elf/Makefile b/elf/Makefile
+index aaa9534..cb8da93 100644
+--- a/elf/Makefile
++++ b/elf/Makefile
+@@ -121,7 +121,8 @@ endif
+ tests = tst-tls1 tst-tls2 tst-tls9 tst-leaks1 \
+ 	tst-array1 tst-array2 tst-array3 tst-array4 tst-array5
+ tests-static = tst-tls1-static tst-tls2-static tst-stackguard1-static \
+-	       tst-leaks1-static tst-array1-static tst-array5-static
++	       tst-leaks1-static tst-array1-static tst-array5-static \
++	       tst-ptrguard1-static
+ ifeq (yes,$(build-shared))
+ tests-static += tst-tls9-static
+ tst-tls9-static-ENV = \
+@@ -145,7 +146,8 @@ tests += loadtest restest1 preloadtest loadfail multiload origtest resolvfail \
+ 	 tst-audit1 tst-audit2 tst-audit8 \
+ 	 tst-stackguard1 tst-addr1 tst-thrlock \
+ 	 tst-unique1 tst-unique2 tst-unique3 tst-unique4 \
+-	 tst-initorder tst-initorder2 tst-relsort1 tst-null-argv
++	 tst-initorder tst-initorder2 tst-relsort1 tst-null-argv \
++	 tst-ptrguard1
+ #	 reldep9
+ test-srcs = tst-pathopt
+ selinux-enabled := $(shell cat /selinux/enforce 2> /dev/null)
+@@ -1016,6 +1018,9 @@ LDFLAGS-order2mod2.so = $(no-as-needed)
+ tst-stackguard1-ARGS = --command "$(host-test-program-cmd) --child"
+ tst-stackguard1-static-ARGS = --command "$(objpfx)tst-stackguard1-static --child"
+ 
++tst-ptrguard1-ARGS = --command "$(host-test-program-cmd) --child"
++tst-ptrguard1-static-ARGS = --command "$(objpfx)tst-ptrguard1-static --child"
++
+ $(objpfx)tst-leaks1: $(libdl)
+ $(objpfx)tst-leaks1-mem: $(objpfx)tst-leaks1.out
+ 	$(common-objpfx)malloc/mtrace $(objpfx)tst-leaks1.mtrace > $@
+diff --git a/elf/tst-ptrguard1-static.c b/elf/tst-ptrguard1-static.c
+new file mode 100644
+index 0000000..7aff3b7
+--- /dev/null
++++ b/elf/tst-ptrguard1-static.c
+@@ -0,0 +1 @@
++#include "tst-ptrguard1.c"
+diff --git a/elf/tst-ptrguard1.c b/elf/tst-ptrguard1.c
+new file mode 100644
+index 0000000..c344a04
+--- /dev/null
++++ b/elf/tst-ptrguard1.c
+@@ -0,0 +1,202 @@
++/* Copyright (C) 2013 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   The GNU C Library is free software; you can redistribute it and/or
++   modify it under the terms of the GNU Lesser General Public
++   License as published by the Free Software Foundation; either
++   version 2.1 of the License, or (at your option) any later version.
++
++   The GNU C Library is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
++   Lesser General Public License for more details.
++
++   You should have received a copy of the GNU Lesser General Public
++   License along with the GNU C Library; if not, see
++   <http://www.gnu.org/licenses/>.  */
++
++#include <errno.h>
++#include <stdbool.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <sys/wait.h>
++#include <stackguard-macros.h>
++#include <tls.h>
++#include <unistd.h>
++
++#ifndef POINTER_CHK_GUARD
++extern uintptr_t __pointer_chk_guard;
++# define POINTER_CHK_GUARD __pointer_chk_guard
++#endif
++
++static const char *command;
++static bool child;
++static uintptr_t ptr_chk_guard_copy;
++static bool ptr_chk_guard_copy_set;
++static int fds[2];
++
++static void __attribute__ ((constructor))
++con (void)
++{
++  ptr_chk_guard_copy = POINTER_CHK_GUARD;
++  ptr_chk_guard_copy_set = true;
++}
++
++static int
++uintptr_t_cmp (const void *a, const void *b)
++{
++  if (*(uintptr_t *) a < *(uintptr_t *) b)
++    return 1;
++  if (*(uintptr_t *) a > *(uintptr_t *) b)
++    return -1;
++  return 0;
++}
++
++static int
++do_test (void)
++{
++  if (!ptr_chk_guard_copy_set)
++    {
++      puts ("constructor has not been run");
++      return 1;
++    }
++
++  if (ptr_chk_guard_copy != POINTER_CHK_GUARD)
++    {
++      puts ("POINTER_CHK_GUARD changed between constructor and do_test");
++      return 1;
++    }
++
++  if (child)
++    {
++      write (2, &ptr_chk_guard_copy, sizeof (ptr_chk_guard_copy));
++      return 0;
++    }
++
++  if (command == NULL)
++    {
++      puts ("missing --command or --child argument");
++      return 1;
++    }
++
++#define N 16
++  uintptr_t child_ptr_chk_guards[N + 1];
++  child_ptr_chk_guards[N] = ptr_chk_guard_copy;
++  int i;
++  for (i = 0; i < N; ++i)
++    {
++      if (pipe (fds) < 0)
++	{
++	  printf ("couldn't create pipe: %m\n");
++	  return 1;
++	}
++
++      pid_t pid = fork ();
++      if (pid < 0)
++	{
++	  printf ("fork failed: %m\n");
++	  return 1;
++	}
++
++      if (!pid)
++	{
++	  if (ptr_chk_guard_copy != POINTER_CHK_GUARD)
++	    {
++	      puts ("POINTER_CHK_GUARD changed after fork");
++	      exit (1);
++	    }
++
++	  close (fds[0]);
++	  close (2);
++	  dup2 (fds[1], 2);
++	  close (fds[1]);
++
++	  system (command);
++	  exit (0);
++	}
++
++      close (fds[1]);
++
++      if (TEMP_FAILURE_RETRY (read (fds[0], &child_ptr_chk_guards[i],
++				    sizeof (uintptr_t))) != sizeof (uintptr_t))
++	{
++	  puts ("could not read ptr_chk_guard value from child");
++	  return 1;
++	}
++
++      close (fds[0]);
++
++      pid_t termpid;
++      int status;
++      termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
++      if (termpid == -1)
++	{
++	  printf ("waitpid failed: %m\n");
++	  return 1;
++	}
++      else if (termpid != pid)
++	{
++	  printf ("waitpid returned %ld != %ld\n",
++		  (long int) termpid, (long int) pid);
++	  return 1;
++	}
++      else if (!WIFEXITED (status) || WEXITSTATUS (status))
++	{
++	  puts ("child hasn't exited with exit status 0");
++	  return 1;
++	}
++    }
++
++  qsort (child_ptr_chk_guards, N + 1, sizeof (uintptr_t), uintptr_t_cmp);
++
++  /* The default pointer guard is the same as the default stack guard.
++     They are only set to default if dl_random is NULL.  */
++  uintptr_t default_guard = 0;
++  unsigned char *p = (unsigned char *) &default_guard;
++  p[sizeof (uintptr_t) - 1] = 255;
++  p[sizeof (uintptr_t) - 2] = '\n';
++  p[0] = 0;
++
++  /* Test if the pointer guard canaries are either randomized,
++     or equal to the default pointer guard value.
++     Even with randomized pointer guards it might happen
++     that the random number generator generates the same
++     values, but if that happens in more than half from
++     the 16 runs, something is very wrong.  */
++  int ndifferences = 0;
++  int ndefaults = 0;
++  for (i = 0; i < N; ++i)
++    {
++      if (child_ptr_chk_guards[i] != child_ptr_chk_guards[i+1])
++	ndifferences++;
++      else if (child_ptr_chk_guards[i] == default_guard)
++	ndefaults++;
++    }
++
++  printf ("differences %d defaults %d\n", ndifferences, ndefaults);
++
++  if (ndifferences < N / 2 && ndefaults < N / 2)
++    {
++      puts ("pointer guard values are not randomized enough");
++      puts ("nor equal to the default value");
++      return 1;
++    }
++
++  return 0;
++}
++
++#define OPT_COMMAND	10000
++#define OPT_CHILD	10001
++#define CMDLINE_OPTIONS	\
++  { "command", required_argument, NULL, OPT_COMMAND },  \
++  { "child", no_argument, NULL, OPT_CHILD },
++#define CMDLINE_PROCESS	\
++  case OPT_COMMAND:	\
++    command = optarg;	\
++    break;		\
++  case OPT_CHILD:	\
++    child = true;	\
++    break;
++#define TEST_FUNCTION do_test ()
++#include "../test-skeleton.c"
+diff --git a/ports/sysdeps/ia64/stackguard-macros.h b/ports/sysdeps/ia64/stackguard-macros.h
+index dc683c2..3907293 100644
+--- a/ports/sysdeps/ia64/stackguard-macros.h
++++ b/ports/sysdeps/ia64/stackguard-macros.h
+@@ -2,3 +2,6 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("adds %0 = -8, r13;; ld8 %0 = [%0]" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("adds %0 = -16, r13;; ld8 %0 = [%0]" : "=r" (x)); x; })
+diff --git a/ports/sysdeps/tile/stackguard-macros.h b/ports/sysdeps/tile/stackguard-macros.h
+index 589ea2b..f2e041b 100644
+--- a/ports/sysdeps/tile/stackguard-macros.h
++++ b/ports/sysdeps/tile/stackguard-macros.h
+@@ -4,11 +4,17 @@
+ # if __WORDSIZE == 64
+ #  define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("addi %0, tp, -16; ld %0, %0" : "=r" (x)); x; })
++#  define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("addi %0, tp, -24; ld %0, %0" : "=r" (x)); x; })
+ # else
+ #  define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("addi %0, tp, -8; ld4s %0, %0" : "=r" (x)); x; })
++#  define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("addi %0, tp, -12; ld4s %0, %0" : "=r" (x)); x; })
+ # endif
+ #else
+ # define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("addi %0, tp, -8; lw %0, %0" : "=r" (x)); x; })
++# define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("addi %0, tp, -12; lw %0, %0" : "=r" (x)); x; })
+ #endif
+diff --git a/sysdeps/generic/stackguard-macros.h b/sysdeps/generic/stackguard-macros.h
+index ababf65..4fa3d96 100644
+--- a/sysdeps/generic/stackguard-macros.h
++++ b/sysdeps/generic/stackguard-macros.h
+@@ -2,3 +2,6 @@
+ 
+ extern uintptr_t __stack_chk_guard;
+ #define STACK_CHK_GUARD __stack_chk_guard
++
++extern uintptr_t __pointer_chk_guard_local;
++#define POINTER_CHK_GUARD __pointer_chk_guard_local
+diff --git a/sysdeps/i386/stackguard-macros.h b/sysdeps/i386/stackguard-macros.h
+index 8c31e19..0397629 100644
+--- a/sysdeps/i386/stackguard-macros.h
++++ b/sysdeps/i386/stackguard-macros.h
+@@ -2,3 +2,11 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("movl %%gs:0x14, %0" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({							\
++     uintptr_t x;					\
++     asm ("movl %%gs:%c1, %0" : "=r" (x)		\
++	  : "i" (offsetof (tcbhead_t, pointer_guard)));	\
++     x;							\
++   })
+diff --git a/sysdeps/powerpc/powerpc32/stackguard-macros.h b/sysdeps/powerpc/powerpc32/stackguard-macros.h
+index 839f6a4..b3d0af8 100644
+--- a/sysdeps/powerpc/powerpc32/stackguard-macros.h
++++ b/sysdeps/powerpc/powerpc32/stackguard-macros.h
+@@ -2,3 +2,13 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("lwz %0,-28680(2)" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({												\
++     uintptr_t x;										\
++     asm ("lwz %0,%1(2)"									\
++	  : "=r" (x)										\
++	  : "i" (offsetof (tcbhead_t, pointer_guard) - TLS_TCB_OFFSET - sizeof (tcbhead_t))	\
++         );											\
++     x;												\
++   })
+diff --git a/sysdeps/powerpc/powerpc64/stackguard-macros.h b/sysdeps/powerpc/powerpc64/stackguard-macros.h
+index 9da879c..4620f96 100644
+--- a/sysdeps/powerpc/powerpc64/stackguard-macros.h
++++ b/sysdeps/powerpc/powerpc64/stackguard-macros.h
+@@ -2,3 +2,13 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("ld %0,-28688(13)" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({												\
++     uintptr_t x;										\
++     asm ("ld %0,%1(2)"										\
++	  : "=r" (x)										\
++	  : "i" (offsetof (tcbhead_t, pointer_guard) - TLS_TCB_OFFSET - sizeof (tcbhead_t))	\
++         );											\
++     x;												\
++   })
+diff --git a/sysdeps/s390/s390-32/stackguard-macros.h b/sysdeps/s390/s390-32/stackguard-macros.h
+index b74c579..449e8d4 100644
+--- a/sysdeps/s390/s390-32/stackguard-macros.h
++++ b/sysdeps/s390/s390-32/stackguard-macros.h
+@@ -2,3 +2,14 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("ear %0,%%a0; l %0,0x14(%0)" : "=a" (x)); x; })
++
++/* On s390/s390x there is no unique pointer guard, instead we use the
++   same value as the stack guard.  */
++#define POINTER_CHK_GUARD \
++  ({							\
++     uintptr_t x;					\
++     asm ("ear %0,%%a0; l %0,%1(%0)"			\
++	  : "=a" (x)					\
++	  : "i" (offsetof (tcbhead_t, stack_guard)));	\
++     x;							\
++   })
+diff --git a/sysdeps/s390/s390-64/stackguard-macros.h b/sysdeps/s390/s390-64/stackguard-macros.h
+index 0cebb5f..c8270fb 100644
+--- a/sysdeps/s390/s390-64/stackguard-macros.h
++++ b/sysdeps/s390/s390-64/stackguard-macros.h
+@@ -2,3 +2,17 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("ear %0,%%a0; sllg %0,%0,32; ear %0,%%a1; lg %0,0x28(%0)" : "=a" (x)); x; })
++
++/* On s390/s390x there is no unique pointer guard, instead we use the
++   same value as the stack guard.  */
++#define POINTER_CHK_GUARD \
++  ({							\
++     uintptr_t x;					\
++     asm ("ear %0,%%a0;"				\
++	  "sllg %0,%0,32;"				\
++	  "ear %0,%%a1;"				\
++	  "lg %0,%1(%0)"				\
++	 : "=a" (x)					\
++	 : "i" (offsetof (tcbhead_t, stack_guard)));	\
++     x;							\
++   })
+diff --git a/sysdeps/sparc/sparc32/stackguard-macros.h b/sysdeps/sparc/sparc32/stackguard-macros.h
+index c0b02b0..1eef0f1 100644
+--- a/sysdeps/sparc/sparc32/stackguard-macros.h
++++ b/sysdeps/sparc/sparc32/stackguard-macros.h
+@@ -2,3 +2,6 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("ld [%%g7+0x14], %0" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("ld [%%g7+0x18], %0" : "=r" (x)); x; })
+diff --git a/sysdeps/sparc/sparc64/stackguard-macros.h b/sysdeps/sparc/sparc64/stackguard-macros.h
+index 80f0635..cc0c12c 100644
+--- a/sysdeps/sparc/sparc64/stackguard-macros.h
++++ b/sysdeps/sparc/sparc64/stackguard-macros.h
+@@ -2,3 +2,6 @@
+ 
+ #define STACK_CHK_GUARD \
+   ({ uintptr_t x; asm ("ldx [%%g7+0x28], %0" : "=r" (x)); x; })
++
++#define POINTER_CHK_GUARD \
++  ({ uintptr_t x; asm ("ldx [%%g7+0x30], %0" : "=r" (x)); x; })
+diff --git a/sysdeps/x86_64/stackguard-macros.h b/sysdeps/x86_64/stackguard-macros.h
+index d7fedb3..1948800 100644
+--- a/sysdeps/x86_64/stackguard-macros.h
++++ b/sysdeps/x86_64/stackguard-macros.h
+@@ -4,3 +4,8 @@
+   ({ uintptr_t x;						\
+      asm ("mov %%fs:%c1, %0" : "=r" (x)				\
+ 	  : "i" (offsetof (tcbhead_t, stack_guard))); x; })
++
++#define POINTER_CHK_GUARD \
++  ({ uintptr_t x;						\
++     asm ("mov %%fs:%c1, %0" : "=r" (x)				\
++	  : "i" (offsetof (tcbhead_t, pointer_guard))); x; })
+diff --git a/elf/Makefile b/elf/Makefile
+index cb8da93..27d249b 100644
+--- a/elf/Makefile
++++ b/elf/Makefile
+@@ -1019,6 +1019,9 @@ tst-stackguard1-ARGS = --command "$(host-test-program-cmd) --child"
+ tst-stackguard1-static-ARGS = --command "$(objpfx)tst-stackguard1-static --child"
+ 
+ tst-ptrguard1-ARGS = --command "$(host-test-program-cmd) --child"
++# When built statically, the pointer guard interface uses
++# __pointer_chk_guard_local.
++CFLAGS-tst-ptrguard1-static.c = -DPTRGUARD_LOCAL
+ tst-ptrguard1-static-ARGS = --command "$(objpfx)tst-ptrguard1-static --child"
+ 
+ $(objpfx)tst-leaks1: $(libdl)
+diff --git a/sysdeps/generic/stackguard-macros.h b/sysdeps/generic/stackguard-macros.h
+index 4fa3d96..b4a6b23 100644
+--- a/sysdeps/generic/stackguard-macros.h
++++ b/sysdeps/generic/stackguard-macros.h
+@@ -3,5 +3,10 @@
+ extern uintptr_t __stack_chk_guard;
+ #define STACK_CHK_GUARD __stack_chk_guard
+ 
++#ifdef PTRGUARD_LOCAL
+ extern uintptr_t __pointer_chk_guard_local;
+-#define POINTER_CHK_GUARD __pointer_chk_guard_local
++# define POINTER_CHK_GUARD __pointer_chk_guard_local
++#else
++extern uintptr_t __pointer_chk_guard;
++# define POINTER_CHK_GUARD __pointer_chk_guard
++#endif
diff --git a/community/glibc-static/glibc-2.18-readdir_r-CVE-2013-4237.patch b/community/glibc-static/glibc-2.18-readdir_r-CVE-2013-4237.patch
new file mode 100644
index 000000000..7277ca229
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-readdir_r-CVE-2013-4237.patch
@@ -0,0 +1,281 @@
+diff --git a/manual/conf.texi b/manual/conf.texi
+index 7eb8b36..c720063 100644
+--- a/manual/conf.texi
++++ b/manual/conf.texi
+@@ -1149,6 +1149,9 @@ typed ahead as input.  @xref{I/O Queues}.
+ @deftypevr Macro int NAME_MAX
+ The uniform system limit (if any) for the length of a file name component, not
+ including the terminating null character.
++
++@strong{Portability Note:} On some systems, @theglibc{} defines
++@code{NAME_MAX}, but does not actually enforce this limit.
+ @end deftypevr
+ 
+ @comment limits.h
+@@ -1157,6 +1160,9 @@ including the terminating null character.
+ The uniform system limit (if any) for the length of an entire file name (that
+ is, the argument given to system calls such as @code{open}), including the
+ terminating null character.
++
++@strong{Portability Note:} @Theglibc{} does not enforce this limit
++even if @code{PATH_MAX} is defined.
+ @end deftypevr
+ 
+ @cindex limits, pipe buffer size
+@@ -1476,6 +1482,9 @@ Inquire about the value of @code{POSIX_REC_MIN_XFER_SIZE}.
+ Inquire about the value of @code{POSIX_REC_XFER_ALIGN}.
+ @end table
+ 
++@strong{Portability Note:} On some systems, @theglibc{} does not
++enforce @code{_PC_NAME_MAX} or @code{_PC_PATH_MAX} limits.
++
+ @node Utility Limits
+ @section Utility Program Capacity Limits
+ 
+diff --git a/manual/filesys.texi b/manual/filesys.texi
+index 1df9cf2..814c210 100644
+--- a/manual/filesys.texi
++++ b/manual/filesys.texi
+@@ -444,9 +444,9 @@ symbols are declared in the header file @file{dirent.h}.
+ @comment POSIX.1
+ @deftypefun {struct dirent *} readdir (DIR *@var{dirstream})
+ This function reads the next entry from the directory.  It normally
+-returns a pointer to a structure containing information about the file.
+-This structure is statically allocated and can be rewritten by a
+-subsequent call.
++returns a pointer to a structure containing information about the
++file.  This structure is associated with the @var{dirstream} handle
++and can be rewritten by a subsequent call.
+ 
+ @strong{Portability Note:} On some systems @code{readdir} may not
+ return entries for @file{.} and @file{..}, even though these are always
+@@ -461,19 +461,61 @@ conditions are defined for this function:
+ The @var{dirstream} argument is not valid.
+ @end table
+ 
+-@code{readdir} is not thread safe.  Multiple threads using
+-@code{readdir} on the same @var{dirstream} may overwrite the return
+-value.  Use @code{readdir_r} when this is critical.
++To distinguish between an end-of-directory condition or an error, you
++must set @code{errno} to zero before calling @code{readdir}.  To avoid
++entering an infinite loop, you should stop reading from the directory
++after the first error.
++
++In POSIX.1-2008, @code{readdir} is not thread-safe.  In @theglibc{}
++implementation, it is safe to call @code{readdir} concurrently on
++different @var{dirstream}s, but multiple threads accessing the same
++@var{dirstream} result in undefined behavior.  @code{readdir_r} is a
++fully thread-safe alternative, but suffers from poor portability (see
++below).  It is recommended that you use @code{readdir}, with external
++locking if multiple threads access the same @var{dirstream}.
+ @end deftypefun
+ 
+ @comment dirent.h
+ @comment GNU
+ @deftypefun int readdir_r (DIR *@var{dirstream}, struct dirent *@var{entry}, struct dirent **@var{result})
+-This function is the reentrant version of @code{readdir}.  Like
+-@code{readdir} it returns the next entry from the directory.  But to
+-prevent conflicts between simultaneously running threads the result is
+-not stored in statically allocated memory.  Instead the argument
+-@var{entry} points to a place to store the result.
++This function is a version of @code{readdir} which performs internal
++locking.  Like @code{readdir} it returns the next entry from the
++directory.  To prevent conflicts between simultaneously running
++threads the result is stored inside the @var{entry} object.
++
++@strong{Portability Note:} It is recommended to use @code{readdir}
++instead of @code{readdir_r} for the following reasons:
++
++@itemize @bullet
++@item
++On systems which do not define @code{NAME_MAX}, it may not be possible
++to use @code{readdir_r} safely because the caller does not specify the
++length of the buffer for the directory entry.
++
++@item
++On some systems, @code{readdir_r} cannot read directory entries with
++very long names.  If such a name is encountered, @theglibc{}
++implementation of @code{readdir_r} returns with an error code of
++@code{ENAMETOOLONG} after the final directory entry has been read.  On
++other systems, @code{readdir_r} may return successfully, but the
++@code{d_name} member may not be NUL-terminated or may be truncated.
++
++@item
++POSIX-1.2008 does not guarantee that @code{readdir} is thread-safe,
++even when access to the same @var{dirstream} is serialized.  But in
++current implementations (including @theglibc{}), it is safe to call
++@code{readdir} concurrently on different @var{dirstream}s, so there is
++no need to use @code{readdir_r} in most multi-threaded programs.  In
++the rare case that multiple threads need to read from the same
++@var{dirstream}, it is still better to use @code{readdir} and external
++synchronization.
++
++@item
++It is expected that future versions of POSIX will obsolete
++@code{readdir_r} and mandate the level of thread safety for
++@code{readdir} which is provided by @theglibc{} and other
++implementations today.
++@end itemize
+ 
+ Normally @code{readdir_r} returns zero and sets @code{*@var{result}}
+ to @var{entry}.  If there are no more entries in the directory or an
+@@ -481,15 +523,6 @@ error is detected, @code{readdir_r} sets @code{*@var{result}} to a
+ null pointer and returns a nonzero error code, also stored in
+ @code{errno}, as described for @code{readdir}.
+ 
+-@strong{Portability Note:} On some systems @code{readdir_r} may not
+-return a NUL terminated string for the file name, even when there is no
+-@code{d_reclen} field in @code{struct dirent} and the file
+-name is the maximum allowed size.  Modern systems all have the
+-@code{d_reclen} field, and on old systems multi-threading is not
+-critical.  In any case there is no such problem with the @code{readdir}
+-function, so that even on systems without the @code{d_reclen} member one
+-could use multiple threads by using external locking.
+-
+ It is also important to look at the definition of the @code{struct
+ dirent} type.  Simply passing a pointer to an object of this type for
+ the second parameter of @code{readdir_r} might not be enough.  Some
+diff --git a/sysdeps/posix/dirstream.h b/sysdeps/posix/dirstream.h
+index a7a074d..8e8570d 100644
+--- a/sysdeps/posix/dirstream.h
++++ b/sysdeps/posix/dirstream.h
+@@ -39,6 +39,8 @@ struct __dirstream
+ 
+     off_t filepos;		/* Position of next entry to read.  */
+ 
++    int errcode;		/* Delayed error code.  */
++
+     /* Directory block.  */
+     char data[0] __attribute__ ((aligned (__alignof__ (void*))));
+   };
+diff --git a/sysdeps/posix/opendir.c b/sysdeps/posix/opendir.c
+index ddfc3a7..fc05b0f 100644
+--- a/sysdeps/posix/opendir.c
++++ b/sysdeps/posix/opendir.c
+@@ -231,6 +231,7 @@ __alloc_dir (int fd, bool close_fd, int flags, const struct stat64 *statp)
+   dirp->size = 0;
+   dirp->offset = 0;
+   dirp->filepos = 0;
++  dirp->errcode = 0;
+ 
+   return dirp;
+ }
+diff --git a/sysdeps/posix/readdir_r.c b/sysdeps/posix/readdir_r.c
+index b5a8e2e..8ed5c3f 100644
+--- a/sysdeps/posix/readdir_r.c
++++ b/sysdeps/posix/readdir_r.c
+@@ -40,6 +40,7 @@ __READDIR_R (DIR *dirp, DIRENT_TYPE *entry, DIRENT_TYPE **result)
+   DIRENT_TYPE *dp;
+   size_t reclen;
+   const int saved_errno = errno;
++  int ret;
+ 
+   __libc_lock_lock (dirp->lock);
+ 
+@@ -70,10 +71,10 @@ __READDIR_R (DIR *dirp, DIRENT_TYPE *entry, DIRENT_TYPE **result)
+ 		  bytes = 0;
+ 		  __set_errno (saved_errno);
+ 		}
++	      if (bytes < 0)
++		dirp->errcode = errno;
+ 
+ 	      dp = NULL;
+-	      /* Reclen != 0 signals that an error occurred.  */
+-	      reclen = bytes != 0;
+ 	      break;
+ 	    }
+ 	  dirp->size = (size_t) bytes;
+@@ -106,29 +107,46 @@ __READDIR_R (DIR *dirp, DIRENT_TYPE *entry, DIRENT_TYPE **result)
+       dirp->filepos += reclen;
+ #endif
+ 
+-      /* Skip deleted files.  */
++#ifdef NAME_MAX
++      if (reclen > offsetof (DIRENT_TYPE, d_name) + NAME_MAX + 1)
++	{
++	  /* The record is very long.  It could still fit into the
++	     caller-supplied buffer if we can skip padding at the
++	     end.  */
++	  size_t namelen = _D_EXACT_NAMLEN (dp);
++	  if (namelen <= NAME_MAX)
++	    reclen = offsetof (DIRENT_TYPE, d_name) + namelen + 1;
++	  else
++	    {
++	      /* The name is too long.  Ignore this file.  */
++	      dirp->errcode = ENAMETOOLONG;
++	      dp->d_ino = 0;
++	      continue;
++	    }
++	}
++#endif
++
++      /* Skip deleted and ignored files.  */
+     }
+   while (dp->d_ino == 0);
+ 
+   if (dp != NULL)
+     {
+-#ifdef GETDENTS_64BIT_ALIGNED
+-      /* The d_reclen value might include padding which is not part of
+-	 the DIRENT_TYPE data structure.  */
+-      reclen = MIN (reclen,
+-		    offsetof (DIRENT_TYPE, d_name) + sizeof (dp->d_name));
+-#endif
+       *result = memcpy (entry, dp, reclen);
+-#ifdef GETDENTS_64BIT_ALIGNED
++#ifdef _DIRENT_HAVE_D_RECLEN
+       entry->d_reclen = reclen;
+ #endif
++      ret = 0;
+     }
+   else
+-    *result = NULL;
++    {
++      *result = NULL;
++      ret = dirp->errcode;
++    }
+ 
+   __libc_lock_unlock (dirp->lock);
+ 
+-  return dp != NULL ? 0 : reclen ? errno : 0;
++  return ret;
+ }
+ 
+ #ifdef __READDIR_R_ALIAS
+diff --git a/sysdeps/posix/rewinddir.c b/sysdeps/posix/rewinddir.c
+index 2935a8e..d4991ad 100644
+--- a/sysdeps/posix/rewinddir.c
++++ b/sysdeps/posix/rewinddir.c
+@@ -33,6 +33,7 @@ rewinddir (dirp)
+   dirp->filepos = 0;
+   dirp->offset = 0;
+   dirp->size = 0;
++  dirp->errcode = 0;
+ #ifndef NOT_IN_libc
+   __libc_lock_unlock (dirp->lock);
+ #endif
+diff --git a/sysdeps/unix/sysv/linux/i386/readdir64_r.c b/sysdeps/unix/sysv/linux/i386/readdir64_r.c
+index 8ebbcfd..a7d114e 100644
+--- a/sysdeps/unix/sysv/linux/i386/readdir64_r.c
++++ b/sysdeps/unix/sysv/linux/i386/readdir64_r.c
+@@ -18,7 +18,6 @@
+ #define __READDIR_R __readdir64_r
+ #define __GETDENTS __getdents64
+ #define DIRENT_TYPE struct dirent64
+-#define GETDENTS_64BIT_ALIGNED 1
+ 
+ #include <sysdeps/posix/readdir_r.c>
+ 
+diff --git a/sysdeps/unix/sysv/linux/wordsize-64/readdir_r.c b/sysdeps/unix/sysv/linux/wordsize-64/readdir_r.c
+index 5ed8e95..290f2c8 100644
+--- a/sysdeps/unix/sysv/linux/wordsize-64/readdir_r.c
++++ b/sysdeps/unix/sysv/linux/wordsize-64/readdir_r.c
+@@ -1,5 +1,4 @@
+ #define readdir64_r __no_readdir64_r_decl
+-#define GETDENTS_64BIT_ALIGNED 1
+ #include <sysdeps/posix/readdir_r.c>
+ #undef readdir64_r
+ weak_alias (__readdir_r, readdir64_r)
+-- 
+1.8.3.4
+
diff --git a/community/glibc-static/glibc-2.18-strcoll-CVE-2012-4412+4424.patch b/community/glibc-static/glibc-2.18-strcoll-CVE-2012-4412+4424.patch
new file mode 100644
index 000000000..5558c1fe9
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-strcoll-CVE-2012-4412+4424.patch
@@ -0,0 +1,1004 @@
+diff --git a/string/strcoll_l.c b/string/strcoll_l.c
+index ecda08f..bb34a72 100644
+--- a/string/strcoll_l.c
++++ b/string/strcoll_l.c
+@@ -41,11 +41,434 @@
+ 
+ #include "../locale/localeinfo.h"
+ 
++/* Track status while looking for sequences in a string.  */
++typedef struct
++{
++  int len;			/* Length of the current sequence.  */
++  size_t val;			/* Position of the sequence relative to the
++				   previous non-ignored sequence.  */
++  size_t idxnow;		/* Current index in sequences.  */
++  size_t idxmax;		/* Maximum index in sequences.  */
++  size_t idxcnt;		/* Current count of indices.  */
++  size_t backw;			/* Current Backward sequence index.  */
++  size_t backw_stop;		/* Index where the backward sequences stop.  */
++  const USTRING_TYPE *us;	/* The string.  */
++  int32_t *idxarr;		/* Array to cache weight indices.  */
++  unsigned char *rulearr;	/* Array to cache rules.  */
++  unsigned char rule;		/* Saved rule for the first sequence.  */
++  int32_t idx;			/* Index to weight of the current sequence.  */
++  int32_t save_idx;		/* Save looked up index of a forward
++				   sequence after the last backward
++				   sequence.  */
++  const USTRING_TYPE *back_us;	/* Beginning of the backward sequence.  */
++} coll_seq;
++
++/* Get next sequence.  The weight indices are cached, so we don't need to
++   traverse the string.  */
++static void
++get_next_seq_cached (coll_seq *seq, int nrules, int pass,
++		     const unsigned char *rulesets,
++		     const USTRING_TYPE *weights)
++{
++  size_t val = seq->val = 0;
++  int len = seq->len;
++  size_t backw_stop = seq->backw_stop;
++  size_t backw = seq->backw;
++  size_t idxcnt = seq->idxcnt;
++  size_t idxmax = seq->idxmax;
++  size_t idxnow = seq->idxnow;
++  unsigned char *rulearr = seq->rulearr;
++  int32_t *idxarr = seq->idxarr;
++
++  while (len == 0)
++    {
++      ++val;
++      if (backw_stop != ~0ul)
++	{
++	  /* There is something pushed.  */
++	  if (backw == backw_stop)
++	    {
++	      /* The last pushed character was handled.  Continue
++		 with forward characters.  */
++	      if (idxcnt < idxmax)
++		{
++		  idxnow = idxcnt;
++		  backw_stop = ~0ul;
++		}
++	      else
++		{
++		  /* Nothing any more.  The backward sequence
++		     ended with the last sequence in the string.  */
++		  idxnow = ~0ul;
++		  break;
++		}
++	    }
++	  else
++	    idxnow = --backw;
++	}
++      else
++	{
++	  backw_stop = idxcnt;
++
++	  while (idxcnt < idxmax)
++	    {
++	      if ((rulesets[rulearr[idxcnt] * nrules + pass]
++		   & sort_backward) == 0)
++		/* No more backward characters to push.  */
++		break;
++	      ++idxcnt;
++	    }
++
++	  if (backw_stop == idxcnt)
++	    {
++	      /* No sequence at all or just one.  */
++	      if (idxcnt == idxmax)
++		/* Note that LEN is still zero.  */
++		break;
++
++	      backw_stop = ~0ul;
++	      idxnow = idxcnt++;
++	    }
++	  else
++	    /* We pushed backward sequences.  */
++	    idxnow = backw = idxcnt - 1;
++	}
++      len = weights[idxarr[idxnow]++];
++    }
++
++  /* Update the structure.  */
++  seq->val = val;
++  seq->len = len;
++  seq->backw_stop = backw_stop;
++  seq->backw = backw;
++  seq->idxcnt = idxcnt;
++  seq->idxnow = idxnow;
++}
++
++/* Get next sequence.  Traverse the string as required.  */
++static void
++get_next_seq (coll_seq *seq, int nrules, const unsigned char *rulesets,
++	      const USTRING_TYPE *weights, const int32_t *table,
++	      const USTRING_TYPE *extra, const int32_t *indirect)
++{
++#include WEIGHT_H
++  size_t val = seq->val = 0;
++  int len = seq->len;
++  size_t backw_stop = seq->backw_stop;
++  size_t backw = seq->backw;
++  size_t idxcnt = seq->idxcnt;
++  size_t idxmax = seq->idxmax;
++  size_t idxnow = seq->idxnow;
++  unsigned char *rulearr = seq->rulearr;
++  int32_t *idxarr = seq->idxarr;
++  const USTRING_TYPE *us = seq->us;
++
++  while (len == 0)
++    {
++      ++val;
++      if (backw_stop != ~0ul)
++	{
++	  /* There is something pushed.  */
++	  if (backw == backw_stop)
++	    {
++	      /* The last pushed character was handled.  Continue
++		 with forward characters.  */
++	      if (idxcnt < idxmax)
++		{
++		  idxnow = idxcnt;
++		  backw_stop = ~0ul;
++		}
++	      else
++		/* Nothing any more.  The backward sequence ended with
++		   the last sequence in the string.  Note that LEN
++		   is still zero.  */
++		break;
++	    }
++	  else
++	    idxnow = --backw;
++	}
++      else
++	{
++	  backw_stop = idxmax;
++
++	  while (*us != L('\0'))
++	    {
++	      int32_t tmp = findidx (&us, -1);
++	      rulearr[idxmax] = tmp >> 24;
++	      idxarr[idxmax] = tmp & 0xffffff;
++	      idxcnt = idxmax++;
++
++	      if ((rulesets[rulearr[idxcnt] * nrules]
++		   & sort_backward) == 0)
++		/* No more backward characters to push.  */
++		break;
++	      ++idxcnt;
++	    }
++
++	  if (backw_stop >= idxcnt)
++	    {
++	      /* No sequence at all or just one.  */
++	      if (idxcnt == idxmax || backw_stop > idxcnt)
++		/* Note that LEN is still zero.  */
++		break;
++
++	      backw_stop = ~0ul;
++	      idxnow = idxcnt;
++	    }
++	  else
++	    /* We pushed backward sequences.  */
++	    idxnow = backw = idxcnt - 1;
++	}
++      len = weights[idxarr[idxnow]++];
++    }
++
++  /* Update the structure.  */
++  seq->val = val;
++  seq->len = len;
++  seq->backw_stop = backw_stop;
++  seq->backw = backw;
++  seq->idxcnt = idxcnt;
++  seq->idxmax = idxmax;
++  seq->idxnow = idxnow;
++  seq->us = us;
++}
++
++/* Get next sequence.  Traverse the string as required.  This function does not
++   set or use any index or rule cache.  */
++static void
++get_next_seq_nocache (coll_seq *seq, int nrules, const unsigned char *rulesets,
++		      const USTRING_TYPE *weights, const int32_t *table,
++		      const USTRING_TYPE *extra, const int32_t *indirect,
++		      int pass)
++{
++#include WEIGHT_H
++  size_t val = seq->val = 0;
++  int len = seq->len;
++  size_t backw_stop = seq->backw_stop;
++  size_t backw = seq->backw;
++  size_t idxcnt = seq->idxcnt;
++  size_t idxmax = seq->idxmax;
++  int32_t idx = seq->idx;
++  const USTRING_TYPE *us = seq->us;
++
++  while (len == 0)
++    {
++      ++val;
++      if (backw_stop != ~0ul)
++	{
++	  /* There is something pushed.  */
++	  if (backw == backw_stop)
++	    {
++	      /* The last pushed character was handled.  Continue
++		 with forward characters.  */
++	      if (idxcnt < idxmax)
++		{
++		  idx = seq->save_idx;
++		  backw_stop = ~0ul;
++		}
++	      else
++		{
++		  /* Nothing anymore.  The backward sequence ended with
++		     the last sequence in the string.  Note that len is
++		     still zero.  */
++		  idx = 0;
++		  break;
++	        }
++	    }
++	  else
++	    {
++	      /* XXX Traverse BACKW sequences from the beginning of
++		 BACKW_STOP to get the next sequence.  Is ther a quicker way
++	         to do this?  */
++	      size_t i = backw_stop;
++	      us = seq->back_us;
++	      while (i < backw)
++		{
++		  int32_t tmp = findidx (&us, -1);
++		  idx = tmp & 0xffffff;
++		  i++;
++		}
++	      --backw;
++	      us = seq->us;
++	    }
++	}
++      else
++	{
++	  backw_stop = idxmax;
++	  int32_t prev_idx = idx;
++
++	  while (*us != L('\0'))
++	    {
++	      int32_t tmp = findidx (&us, -1);
++	      unsigned char rule = tmp >> 24;
++	      prev_idx = idx;
++	      idx = tmp & 0xffffff;
++	      idxcnt = idxmax++;
++
++	      /* Save the rule for the first sequence.  */
++	      if (__glibc_unlikely (idxcnt == 0))
++	        seq->rule = rule;
++
++	      if ((rulesets[rule * nrules + pass]
++		   & sort_backward) == 0)
++		/* No more backward characters to push.  */
++		break;
++	      ++idxcnt;
++	    }
++
++	  if (backw_stop >= idxcnt)
++	    {
++	      /* No sequence at all or just one.  */
++	      if (idxcnt == idxmax || backw_stop > idxcnt)
++		/* Note that len is still zero.  */
++		break;
++
++	      backw_stop = ~0ul;
++	    }
++	  else
++	    {
++	      /* We pushed backward sequences.  If the stream ended with the
++		 backward sequence, then we process the last sequence we
++		 found.  Otherwise we process the sequence before the last
++		 one since the last one was a forward sequence.  */
++	      seq->back_us = seq->us;
++	      seq->us = us;
++	      backw = idxcnt;
++	      if (idxmax > idxcnt)
++		{
++		  backw--;
++		  seq->save_idx = idx;
++		  idx = prev_idx;
++		}
++	      if (backw > backw_stop)
++		backw--;
++	    }
++	}
++
++      len = weights[idx++];
++      /* Skip over indices of previous levels.  */
++      for (int i = 0; i < pass; i++)
++	{
++	  idx += len;
++	  len = weights[idx];
++	  idx++;
++	}
++    }
++
++  /* Update the structure.  */
++  seq->val = val;
++  seq->len = len;
++  seq->backw_stop = backw_stop;
++  seq->backw = backw;
++  seq->idxcnt = idxcnt;
++  seq->idxmax = idxmax;
++  seq->us = us;
++  seq->idx = idx;
++}
++
++/* Compare two sequences.  This version does not use the index and rules
++   cache.  */
++static int
++do_compare_nocache (coll_seq *seq1, coll_seq *seq2, int position,
++		    const USTRING_TYPE *weights)
++{
++  int seq1len = seq1->len;
++  int seq2len = seq2->len;
++  size_t val1 = seq1->val;
++  size_t val2 = seq2->val;
++  int idx1 = seq1->idx;
++  int idx2 = seq2->idx;
++  int result = 0;
++
++  /* Test for position if necessary.  */
++  if (position && val1 != val2)
++    {
++      result = val1 > val2 ? 1 : -1;
++      goto out;
++    }
++
++  /* Compare the two sequences.  */
++  do
++    {
++      if (weights[idx1] != weights[idx2])
++	{
++	  /* The sequences differ.  */
++	  result = weights[idx1] - weights[idx2];
++	  goto out;
++	}
++
++      /* Increment the offsets.  */
++      ++idx1;
++      ++idx2;
++
++      --seq1len;
++      --seq2len;
++    }
++  while (seq1len > 0 && seq2len > 0);
++
++  if (position && seq1len != seq2len)
++    result = seq1len - seq2len;
++
++out:
++  seq1->len = seq1len;
++  seq2->len = seq2len;
++  seq1->idx = idx1;
++  seq2->idx = idx2;
++  return result;
++}
++
++/* Compare two sequences using the index cache.  */
++static int
++do_compare (coll_seq *seq1, coll_seq *seq2, int position,
++	    const USTRING_TYPE *weights)
++{
++  int seq1len = seq1->len;
++  int seq2len = seq2->len;
++  size_t val1 = seq1->val;
++  size_t val2 = seq2->val;
++  int32_t *idx1arr = seq1->idxarr;
++  int32_t *idx2arr = seq2->idxarr;
++  int idx1now = seq1->idxnow;
++  int idx2now = seq2->idxnow;
++  int result = 0;
++
++  /* Test for position if necessary.  */
++  if (position && val1 != val2)
++    {
++      result = val1 > val2 ? 1 : -1;
++      goto out;
++    }
++
++  /* Compare the two sequences.  */
++  do
++    {
++      if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
++	{
++	  /* The sequences differ.  */
++	  result = weights[idx1arr[idx1now]] - weights[idx2arr[idx2now]];
++	  goto out;
++	}
++
++      /* Increment the offsets.  */
++      ++idx1arr[idx1now];
++      ++idx2arr[idx2now];
++
++      --seq1len;
++      --seq2len;
++    }
++  while (seq1len > 0 && seq2len > 0);
++
++  if (position && seq1len != seq2len)
++    result = seq1len - seq2len;
++
++out:
++  seq1->len = seq1len;
++  seq2->len = seq2len;
++  return result;
++}
++
+ int
+-STRCOLL (s1, s2, l)
+-     const STRING_TYPE *s1;
+-     const STRING_TYPE *s2;
+-     __locale_t l;
++STRCOLL (const STRING_TYPE *s1, const STRING_TYPE *s2, __locale_t l)
+ {
+   struct __locale_data *current = l->__locales[LC_COLLATE];
+   uint_fast32_t nrules = current->values[_NL_ITEM_INDEX (_NL_COLLATE_NRULES)].word;
+@@ -56,34 +479,6 @@ STRCOLL (s1, s2, l)
+   const USTRING_TYPE *weights;
+   const USTRING_TYPE *extra;
+   const int32_t *indirect;
+-  uint_fast32_t pass;
+-  int result = 0;
+-  const USTRING_TYPE *us1;
+-  const USTRING_TYPE *us2;
+-  size_t s1len;
+-  size_t s2len;
+-  int32_t *idx1arr;
+-  int32_t *idx2arr;
+-  unsigned char *rule1arr;
+-  unsigned char *rule2arr;
+-  size_t idx1max;
+-  size_t idx2max;
+-  size_t idx1cnt;
+-  size_t idx2cnt;
+-  size_t idx1now;
+-  size_t idx2now;
+-  size_t backw1_stop;
+-  size_t backw2_stop;
+-  size_t backw1;
+-  size_t backw2;
+-  int val1;
+-  int val2;
+-  int position;
+-  int seq1len;
+-  int seq2len;
+-  int use_malloc;
+-
+-#include WEIGHT_H
+ 
+   if (nrules == 0)
+     return STRCMP (s1, s2);
+@@ -98,7 +493,6 @@ STRCOLL (s1, s2, l)
+     current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_EXTRA,SUFFIX))].string;
+   indirect = (const int32_t *)
+     current->values[_NL_ITEM_INDEX (CONCAT(_NL_COLLATE_INDIRECT,SUFFIX))].string;
+-  use_malloc = 0;
+ 
+   assert (((uintptr_t) table) % __alignof__ (table[0]) == 0);
+   assert (((uintptr_t) weights) % __alignof__ (weights[0]) == 0);
+@@ -106,18 +500,13 @@ STRCOLL (s1, s2, l)
+   assert (((uintptr_t) indirect) % __alignof__ (indirect[0]) == 0);
+ 
+   /* We need this a few times.  */
+-  s1len = STRLEN (s1);
+-  s2len = STRLEN (s2);
++  size_t s1len = STRLEN (s1);
++  size_t s2len = STRLEN (s2);
+ 
+   /* Catch empty strings.  */
+-  if (__builtin_expect (s1len == 0, 0) || __builtin_expect (s2len == 0, 0))
++  if (__glibc_unlikely (s1len == 0) || __glibc_unlikely (s2len == 0))
+     return (s1len != 0) - (s2len != 0);
+ 
+-  /* We need the elements of the strings as unsigned values since they
+-     are used as indeces.  */
+-  us1 = (const USTRING_TYPE *) s1;
+-  us2 = (const USTRING_TYPE *) s2;
+-
+   /* Perform the first pass over the string and while doing this find
+      and store the weights for each character.  Since we want this to
+      be as fast as possible we are using `alloca' to store the temporary
+@@ -127,411 +516,124 @@ STRCOLL (s1, s2, l)
+ 
+      Please note that the localedef programs makes sure that `position'
+      is not used at the first level.  */
+-  if (! __libc_use_alloca ((s1len + s2len) * (sizeof (int32_t) + 1)))
+-    {
+-      idx1arr = (int32_t *) malloc ((s1len + s2len) * (sizeof (int32_t) + 1));
+-      idx2arr = &idx1arr[s1len];
+-      rule1arr = (unsigned char *) &idx2arr[s2len];
+-      rule2arr = &rule1arr[s1len];
+-
+-      if (idx1arr == NULL)
+-	/* No memory.  Well, go with the stack then.
+-
+-	   XXX Once this implementation is stable we will handle this
+-	   differently.  Instead of precomputing the indeces we will
+-	   do this in time.  This means, though, that this happens for
+-	   every pass again.  */
+-	goto try_stack;
+-      use_malloc = 1;
+-    }
+-  else
+-    {
+-    try_stack:
+-      idx1arr = (int32_t *) alloca (s1len * sizeof (int32_t));
+-      idx2arr = (int32_t *) alloca (s2len * sizeof (int32_t));
+-      rule1arr = (unsigned char *) alloca (s1len);
+-      rule2arr = (unsigned char *) alloca (s2len);
+-    }
+ 
+-  idx1cnt = 0;
+-  idx2cnt = 0;
+-  idx1max = 0;
+-  idx2max = 0;
+-  idx1now = 0;
+-  idx2now = 0;
+-  backw1_stop = ~0ul;
+-  backw2_stop = ~0ul;
+-  backw1 = ~0ul;
+-  backw2 = ~0ul;
+-  seq1len = 0;
+-  seq2len = 0;
+-  position = rulesets[0] & sort_position;
+-  while (1)
+-    {
+-      val1 = 0;
+-      val2 = 0;
+-
+-      /* Get the next non-IGNOREd element for string `s1'.  */
+-      if (seq1len == 0)
+-	do
+-	  {
+-	    ++val1;
+-
+-	    if (backw1_stop != ~0ul)
+-	      {
+-		/* The is something pushed.  */
+-		if (backw1 == backw1_stop)
+-		  {
+-		    /* The last pushed character was handled.  Continue
+-		       with forward characters.  */
+-		    if (idx1cnt < idx1max)
+-		      {
+-			idx1now = idx1cnt;
+-			backw1_stop = ~0ul;
+-		      }
+-		    else
+-		      /* Nothing anymore.  The backward sequence ended with
+-			 the last sequence in the string.  Note that seq1len
+-			 is still zero.  */
+-		      break;
+-		  }
+-		else
+-		  idx1now = --backw1;
+-	      }
+-	    else
+-	      {
+-		backw1_stop = idx1max;
+-
+-		while (*us1 != L('\0'))
+-		  {
+-		    int32_t tmp = findidx (&us1, -1);
+-		    rule1arr[idx1max] = tmp >> 24;
+-		    idx1arr[idx1max] = tmp & 0xffffff;
+-		    idx1cnt = idx1max++;
+-
+-		    if ((rulesets[rule1arr[idx1cnt] * nrules]
+-			 & sort_backward) == 0)
+-		      /* No more backward characters to push.  */
+-		      break;
+-		    ++idx1cnt;
+-		  }
+-
+-		if (backw1_stop >= idx1cnt)
+-		  {
+-		    /* No sequence at all or just one.  */
+-		    if (idx1cnt == idx1max || backw1_stop > idx1cnt)
+-		      /* Note that seq1len is still zero.  */
+-		      break;
+-
+-		    backw1_stop = ~0ul;
+-		    idx1now = idx1cnt;
+-		  }
+-		else
+-		  /* We pushed backward sequences.  */
+-		  idx1now = backw1 = idx1cnt - 1;
+-	      }
+-	  }
+-	while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
+-
+-      /* And the same for string `s2'.  */
+-      if (seq2len == 0)
+-	do
+-	  {
+-	    ++val2;
+-
+-	    if (backw2_stop != ~0ul)
+-	      {
+-		/* The is something pushed.  */
+-		if (backw2 == backw2_stop)
+-		  {
+-		    /* The last pushed character was handled.  Continue
+-		       with forward characters.  */
+-		    if (idx2cnt < idx2max)
+-		      {
+-			idx2now = idx2cnt;
+-			backw2_stop = ~0ul;
+-		      }
+-		    else
+-		      /* Nothing anymore.  The backward sequence ended with
+-			 the last sequence in the string.  Note that seq2len
+-			 is still zero.  */
+-		      break;
+-		  }
+-		else
+-		  idx2now = --backw2;
+-	      }
+-	    else
+-	      {
+-		backw2_stop = idx2max;
+-
+-		while (*us2 != L('\0'))
+-		  {
+-		    int32_t tmp = findidx (&us2, -1);
+-		    rule2arr[idx2max] = tmp >> 24;
+-		    idx2arr[idx2max] = tmp & 0xffffff;
+-		    idx2cnt = idx2max++;
+-
+-		    if ((rulesets[rule2arr[idx2cnt] * nrules]
+-			 & sort_backward) == 0)
+-		      /* No more backward characters to push.  */
+-		      break;
+-		    ++idx2cnt;
+-		  }
+-
+-		if (backw2_stop >= idx2cnt)
+-		  {
+-		    /* No sequence at all or just one.  */
+-		    if (idx2cnt == idx2max || backw2_stop > idx2cnt)
+-		      /* Note that seq1len is still zero.  */
+-		      break;
+-
+-		    backw2_stop = ~0ul;
+-		    idx2now = idx2cnt;
+-		  }
+-		else
+-		  /* We pushed backward sequences.  */
+-		  idx2now = backw2 = idx2cnt - 1;
+-	      }
+-	  }
+-	while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
+-
+-      /* See whether any or both strings are empty.  */
+-      if (seq1len == 0 || seq2len == 0)
+-	{
+-	  if (seq1len == seq2len)
+-	    /* Both ended.  So far so good, both strings are equal at the
+-	       first level.  */
+-	    break;
+-
+-	  /* This means one string is shorter than the other.  Find out
+-	     which one and return an appropriate value.  */
+-	  result = seq1len == 0 ? -1 : 1;
+-	  goto free_and_return;
+-	}
++  coll_seq seq1, seq2;
++  bool use_malloc = false;
++  int result = 0;
+ 
+-      /* Test for position if necessary.  */
+-      if (position && val1 != val2)
+-	{
+-	  result = val1 - val2;
+-	  goto free_and_return;
+-	}
++  memset (&seq1, 0, sizeof (seq1));
++  seq2 = seq1;
+ 
+-      /* Compare the two sequences.  */
+-      do
+-	{
+-	  if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
+-	    {
+-	      /* The sequences differ.  */
+-	      result = weights[idx1arr[idx1now]] - weights[idx2arr[idx2now]];
+-	      goto free_and_return;
+-	    }
++  size_t size_max = SIZE_MAX / (sizeof (int32_t) + 1);
+ 
+-	  /* Increment the offsets.  */
+-	  ++idx1arr[idx1now];
+-	  ++idx2arr[idx2now];
++  /* If the strings are long enough to cause overflow in the size request, then
++     skip the allocation and proceed with the non-cached routines.  */
++  if (MIN (s1len, s2len) > size_max
++      || MAX (s1len, s2len) > size_max - MIN (s1len, s2len))
++    goto begin_collate;
+ 
+-	  --seq1len;
+-	  --seq2len;
+-	}
+-      while (seq1len > 0 && seq2len > 0);
++  if (! __libc_use_alloca ((s1len + s2len) * (sizeof (int32_t) + 1)))
++    {
++      seq1.idxarr = (int32_t *) malloc ((s1len + s2len) * (sizeof (int32_t) + 1));
+ 
+-      if (position && seq1len != seq2len)
++      /* If we failed to allocate memory, we leave everything as NULL so that
++	 we use the nocache version of traversal and comparison functions.  */
++      if (seq1.idxarr != NULL)
+ 	{
+-	  result = seq1len - seq2len;
+-	  goto free_and_return;
++	  seq2.idxarr = &seq1.idxarr[s1len];
++	  seq1.rulearr = (unsigned char *) &seq2.idxarr[s2len];
++	  seq2.rulearr = &seq1.rulearr[s1len];
++	  use_malloc = true;
+ 	}
+     }
++  else
++    {
++      seq1.idxarr = (int32_t *) alloca (s1len * sizeof (int32_t));
++      seq2.idxarr = (int32_t *) alloca (s2len * sizeof (int32_t));
++      seq1.rulearr = (unsigned char *) alloca (s1len);
++      seq2.rulearr = (unsigned char *) alloca (s2len);
++    }
+ 
+-  /* Now the remaining passes over the weights.  We now use the
+-     indeces we found before.  */
+-  for (pass = 1; pass < nrules; ++pass)
++  int rule;
++
++ begin_collate:
++  rule = 0;
++  /* Cache values in the first pass and if needed, use them in subsequent
++     passes.  */
++  for (int pass = 0; pass < nrules; ++pass)
+     {
++      seq1.idxcnt = 0;
++      seq1.idx = 0;
++      seq2.idx = 0;
++      seq1.backw_stop = ~0ul;
++      seq1.backw = ~0ul;
++      seq2.idxcnt = 0;
++      seq2.backw_stop = ~0ul;
++      seq2.backw = ~0ul;
++
++      /* We need the elements of the strings as unsigned values since they
++	 are used as indices.  */
++      seq1.us = (const USTRING_TYPE *) s1;
++      seq2.us = (const USTRING_TYPE *) s2;
++
+       /* We assume that if a rule has defined `position' in one section
+ 	 this is true for all of them.  */
+-      idx1cnt = 0;
+-      idx2cnt = 0;
+-      backw1_stop = ~0ul;
+-      backw2_stop = ~0ul;
+-      backw1 = ~0ul;
+-      backw2 = ~0ul;
+-      position = rulesets[rule1arr[0] * nrules + pass] & sort_position;
++      int position = rulesets[rule * nrules + pass] & sort_position;
+ 
+       while (1)
+ 	{
+-	  val1 = 0;
+-	  val2 = 0;
+-
+-	  /* Get the next non-IGNOREd element for string `s1'.  */
+-	  if (seq1len == 0)
+-	    do
+-	      {
+-		++val1;
+-
+-		if (backw1_stop != ~0ul)
+-		  {
+-		    /* The is something pushed.  */
+-		    if (backw1 == backw1_stop)
+-		      {
+-			/* The last pushed character was handled.  Continue
+-			   with forward characters.  */
+-			if (idx1cnt < idx1max)
+-			  {
+-			    idx1now = idx1cnt;
+-			    backw1_stop = ~0ul;
+-			  }
+-			else
+-			  {
+-			    /* Nothing anymore.  The backward sequence
+-			       ended with the last sequence in the string.  */
+-			    idx1now = ~0ul;
+-			    break;
+-			  }
+-		      }
+-		    else
+-		      idx1now = --backw1;
+-		  }
+-		else
+-		  {
+-		    backw1_stop = idx1cnt;
+-
+-		    while (idx1cnt < idx1max)
+-		      {
+-			if ((rulesets[rule1arr[idx1cnt] * nrules + pass]
+-			     & sort_backward) == 0)
+-			  /* No more backward characters to push.  */
+-			  break;
+-			++idx1cnt;
+-		      }
+-
+-		    if (backw1_stop == idx1cnt)
+-		      {
+-			/* No sequence at all or just one.  */
+-			if (idx1cnt == idx1max)
+-			  /* Note that seq1len is still zero.  */
+-			  break;
+-
+-			backw1_stop = ~0ul;
+-			idx1now = idx1cnt++;
+-		      }
+-		    else
+-		      /* We pushed backward sequences.  */
+-		      idx1now = backw1 = idx1cnt - 1;
+-		  }
+-	      }
+-	    while ((seq1len = weights[idx1arr[idx1now]++]) == 0);
+-
+-	  /* And the same for string `s2'.  */
+-	  if (seq2len == 0)
+-	    do
+-	      {
+-		++val2;
+-
+-		if (backw2_stop != ~0ul)
+-		  {
+-		    /* The is something pushed.  */
+-		    if (backw2 == backw2_stop)
+-		      {
+-			/* The last pushed character was handled.  Continue
+-			   with forward characters.  */
+-			if (idx2cnt < idx2max)
+-			  {
+-			    idx2now = idx2cnt;
+-			    backw2_stop = ~0ul;
+-			  }
+-			else
+-			  {
+-			    /* Nothing anymore.  The backward sequence
+-			       ended with the last sequence in the string.  */
+-			    idx2now = ~0ul;
+-			    break;
+-			  }
+-		      }
+-		    else
+-		      idx2now = --backw2;
+-		  }
+-		else
+-		  {
+-		    backw2_stop = idx2cnt;
+-
+-		    while (idx2cnt < idx2max)
+-		      {
+-			if ((rulesets[rule2arr[idx2cnt] * nrules + pass]
+-			     & sort_backward) == 0)
+-			  /* No more backward characters to push.  */
+-			  break;
+-			++idx2cnt;
+-		      }
+-
+-		    if (backw2_stop == idx2cnt)
+-		      {
+-			/* No sequence at all or just one.  */
+-			if (idx2cnt == idx2max)
+-			  /* Note that seq2len is still zero.  */
+-			  break;
+-
+-			backw2_stop = ~0ul;
+-			idx2now = idx2cnt++;
+-		      }
+-		    else
+-		      /* We pushed backward sequences.  */
+-		      idx2now = backw2 = idx2cnt - 1;
+-		  }
+-	      }
+-	    while ((seq2len = weights[idx2arr[idx2now]++]) == 0);
++	  if (__glibc_unlikely (seq1.idxarr == NULL))
++	    {
++	      get_next_seq_nocache (&seq1, nrules, rulesets, weights, table,
++				    extra, indirect, pass);
++	      get_next_seq_nocache (&seq2, nrules, rulesets, weights, table,
++				    extra, indirect, pass);
++	    }
++	  else if (pass == 0)
++	    {
++	      get_next_seq (&seq1, nrules, rulesets, weights, table, extra,
++			    indirect);
++	      get_next_seq (&seq2, nrules, rulesets, weights, table, extra,
++			    indirect);
++	    }
++	  else
++	    {
++	      get_next_seq_cached (&seq1, nrules, pass, rulesets, weights);
++	      get_next_seq_cached (&seq2, nrules, pass, rulesets, weights);
++	    }
+ 
+ 	  /* See whether any or both strings are empty.  */
+-	  if (seq1len == 0 || seq2len == 0)
++	  if (seq1.len == 0 || seq2.len == 0)
+ 	    {
+-	      if (seq1len == seq2len)
++	      if (seq1.len == seq2.len)
+ 		/* Both ended.  So far so good, both strings are equal
+ 		   at this level.  */
+ 		break;
+ 
+ 	      /* This means one string is shorter than the other.  Find out
+ 		 which one and return an appropriate value.  */
+-	      result = seq1len == 0 ? -1 : 1;
++	      result = seq1.len == 0 ? -1 : 1;
+ 	      goto free_and_return;
+ 	    }
+ 
+-	  /* Test for position if necessary.  */
+-	  if (position && val1 != val2)
+-	    {
+-	      result = val1 - val2;
+-	      goto free_and_return;
+-	    }
+-
+-	  /* Compare the two sequences.  */
+-	  do
+-	    {
+-	      if (weights[idx1arr[idx1now]] != weights[idx2arr[idx2now]])
+-		{
+-		  /* The sequences differ.  */
+-		  result = (weights[idx1arr[idx1now]]
+-			    - weights[idx2arr[idx2now]]);
+-		  goto free_and_return;
+-		}
+-
+-	      /* Increment the offsets.  */
+-	      ++idx1arr[idx1now];
+-	      ++idx2arr[idx2now];
+-
+-	      --seq1len;
+-	      --seq2len;
+-	    }
+-	  while (seq1len > 0 && seq2len > 0);
+-
+-	  if (position && seq1len != seq2len)
+-	    {
+-	      result = seq1len - seq2len;
+-	      goto free_and_return;
+-	    }
++	  if (__glibc_unlikely (seq1.idxarr == NULL))
++	    result = do_compare_nocache (&seq1, &seq2, position, weights);
++	  else
++	    result = do_compare (&seq1, &seq2, position, weights);
++	  if (result != 0)
++	    goto free_and_return;
+ 	}
++
++      if (__glibc_likely (seq1.rulearr != NULL))
++	rule = seq1.rulearr[0];
++      else
++	rule = seq1.rule;
+     }
+ 
+   /* Free the memory if needed.  */
+  free_and_return:
+   if (use_malloc)
+-    free (idx1arr);
++    free (seq1.idxarr);
+ 
+   return result;
+ }
diff --git a/community/glibc-static/glibc-2.18-strstr-hackfix.patch b/community/glibc-static/glibc-2.18-strstr-hackfix.patch
new file mode 100644
index 000000000..6149f88bc
--- /dev/null
+++ b/community/glibc-static/glibc-2.18-strstr-hackfix.patch
@@ -0,0 +1,13 @@
+diff --git a/sysdeps/x86_64/multiarch/strstr.c b/sysdeps/x86_64/multiarch/strstr.c
+index cd63b68..03d8b9a 100644
+--- a/sysdeps/x86_64/multiarch/strstr.c
++++ b/sysdeps/x86_64/multiarch/strstr.c
+@@ -86,7 +86,7 @@
+ /* Simple replacement of movdqu to address 4KB boundary cross issue.
+    If EOS occurs within less than 16B before 4KB boundary, we don't
+    cross to next page.  */
+-static __m128i
++static inline __m128i
+ __m128i_strloadu (const unsigned char * p, __m128i zero)
+ {
+   if (__builtin_expect ((int) ((size_t) p & 0xfff) > 0xff0, 0))
diff --git a/community/hedgewars/PKGBUILD b/community/hedgewars/PKGBUILD
index 0c1b5318d..70ecc64ff 100644
--- a/community/hedgewars/PKGBUILD
+++ b/community/hedgewars/PKGBUILD
@@ -1,8 +1,8 @@
-# $Id: PKGBUILD 103142 2013-12-27 12:15:28Z spupykin $
+# $Id: PKGBUILD 103306 2014-01-02 22:43:13Z spupykin $
 # Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
 
 pkgname=hedgewars
-pkgver=0.9.20
+pkgver=0.9.20.3
 pkgrel=1
 pkgdesc="turn based strategy, artillery, action and comedy game, featuring the
  antics of pink hedgehogs with attitude as they battle from the depths of hell
@@ -23,7 +23,7 @@ makedepends=('fpc' 'cmake'
 	     'haskell-random')
 source=(http://download.gna.org/hedgewars/hedgewars-src-$pkgver.tar.bz2
 	hedgewars.png)
-md5sums=('7ee1b23e51053d34feb84464184f60fa'
+md5sums=('cea4def4e212905026ef29e00447b966'
          'eeb14d50df39063549ac5eca9dbc65d1')
 
 build() {
diff --git a/community/hwinfo/PKGBUILD b/community/hwinfo/PKGBUILD
index 11bd4bb06..0b790dbae 100644
--- a/community/hwinfo/PKGBUILD
+++ b/community/hwinfo/PKGBUILD
@@ -1,4 +1,4 @@
-# $Id: PKGBUILD 90497 2013-05-12 23:11:39Z arodseth $
+# $Id: PKGBUILD 103280 2014-01-02 12:43:36Z arodseth $
 # Maintainer: Alexander Rødseth <rodseth@gmail.com>
 # Contributor: Kaiting Chen <kaitocracy@gmail.com>
 # Contributor: Gergely Imreh <imrehgATgmailDOTcom>
@@ -8,23 +8,22 @@
 # Contributor: ninja_pt
 
 pkgname=hwinfo
-pkgver=20.1
-_subver=3.10
-pkgrel=2
+pkgver=21.0
+_subver=1.2
+pkgrel=1
 pkgdesc='Hardware detection tool from openSUSE'
 arch=('x86_64' 'i686')
 url='http://download.opensuse.org/source/factory/repo/oss/suse/src/'
 license=('GPL2')
 depends=('perl' 'libx86emu')
 makedepends=('sysfsutils' 'rpmextract' 'flex')
+options=('!emptydirs')
 source=("http://download.opensuse.org/source/factory/repo/oss/suse/src/$pkgname-$pkgver-$_subver.src.rpm"
         'custom_ioctl.patch')
-sha256sums=('b0e2e51b4dd754071fb40843deaaafb0755388de5335b1d2c4c081d0f6393841'
+sha256sums=('4126875621a935a450cf616b69a1f922047f241cedc3ac02ece54cd78b23a9fb'
             '6e83b50aa34f31db5fe6de938402e7c4dda6ffa9ffe1346c076e4779018fcf1d')
 
 prepare() {
-  cd "$srcdir"
-
   rpmextract.sh "$pkgname-$pkgver-$_subver.src.rpm"
   tar jxf $pkgname-$pkgver.tar.bz2
   cd "$pkgname-$pkgver"
@@ -32,17 +31,14 @@ prepare() {
 }
 
 build() {
-  cd "$srcdir/$pkgname-$pkgver"
-
-  make -j1 CFLAGS+="-fPIC -I$srcdir/$pkgname-$pkgver/src/hd" LIBDIR=/usr/lib
+  make -C "$pkgname-$pkgver" -j1 \
+    CFLAGS+="-fPIC -I$srcdir/$pkgname-$pkgver/src/hd" \
+    LIBDIR=/usr/lib
 }
 
 package() {
-  cd "$srcdir/$pkgname-$pkgver"
-
-  make LIBDIR=/usr/lib DESTDIR="$pkgdir" install
+  make -C "$pkgname-$pkgver" LIBDIR=/usr/lib DESTDIR="$pkgdir" install
   mv "$pkgdir/usr/sbin" "$pkgdir/usr/bin"
-  rmdir "$pkgdir/sbin"
 }
 
 # vim:set ts=2 sw=2 et:
diff --git a/community/kbibtex/PKGBUILD b/community/kbibtex/PKGBUILD
index abcd8d8b8..0520ba976 100644
--- a/community/kbibtex/PKGBUILD
+++ b/community/kbibtex/PKGBUILD
@@ -1,26 +1,27 @@
-# $Id: PKGBUILD 87529 2013-04-02 15:44:34Z schiv $
+# $Id: PKGBUILD 103296 2014-01-02 21:08:34Z schiv $
 # Maintainer: Ray Rashif <schiv@archlinux.org>
 # Contributor: Antonio Rojas <nqn1976 @ gmail.com>
 # Contributor: cmorlok <christianmorlok@web.de>
 
 pkgname=kbibtex
-pkgver=0.4.1
-_branch=0.4
-pkgrel=2
+pkgver=0.5
+_branch=0.5
+pkgrel=1
 pkgdesc="A BibTeX editor for KDE"
 arch=('i686' 'x86_64')
 url='http://home.gna.org/kbibtex/'
 license=('GPL')
-depends=('kdebase-runtime' 'kdegraphics-okular')
+depends=('kdebase-runtime')
+optdepends=('kdegraphics-okular: Document preview')
 makedepends=('cmake' 'automoc4')
 install=$pkgname.install
-source=("http://download.gna.org/$pkgname/$_branch/$pkgname-$pkgver.tar.bz2")
-md5sums=('657eda1da48198a3c336ff268ce46d6f')
+source=("http://download.gna.org/$pkgname/$_branch/$pkgname-$pkgver.tar.xz")
+md5sums=('bbd2affd1edfb8f02a077c2c7cfc2038')
 
 build() {
   cd "$pkgname-$pkgver"
 
-  cmake -DCMAKE_INSTALL_PREFIX=/usr
+  cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release
   make
 }
 
diff --git a/community/kbibtex/kbibtex.install b/community/kbibtex/kbibtex.install
index 139cb5694..3f22aadfb 100644
--- a/community/kbibtex/kbibtex.install
+++ b/community/kbibtex/kbibtex.install
@@ -1,15 +1,15 @@
 post_install() {
-	xdg-icon-resource forceupdate --theme hicolor &> /dev/null
+  xdg-icon-resource forceupdate --theme hicolor &> /dev/null
   update-mime-database usr/share/mime &> /dev/null
   update-desktop-database -q
 }
 
 post_upgrade() {
-	post_install
+  post_install
 }
 
 post_remove() {
-	post_install
+  post_install
 }
 
 # vim:set ts=2 sw=2 et:
diff --git a/community/lilypond/PKGBUILD b/community/lilypond/PKGBUILD
index ce971f550..473c7e418 100644
--- a/community/lilypond/PKGBUILD
+++ b/community/lilypond/PKGBUILD
@@ -1,12 +1,12 @@
-# $Id: PKGBUILD 103224 2013-12-30 15:18:05Z bgyorgy $
+# $Id: PKGBUILD 103308 2014-01-02 22:45:42Z spupykin $
 # Maintainer: Sergej Pupykin <pupykin.s+arch@gmail.com>
 # Maintainer: Geoffroy Carrier <geoffroy@archlinux.org>
 # Contributor: William Rea <sillywilly@gmail.com>
 # Contributor: Robert Emil Berge <filoktetes@linuxophic.org>
 
 pkgname=lilypond
-pkgver=2.16.2
-pkgrel=5
+pkgver=2.18.0
+pkgrel=1
 pkgdesc="An automated music engraving system"
 arch=('i686' 'x86_64')
 url="http://lilypond.org"
@@ -16,12 +16,8 @@ makedepends=('flex' 'bison' 'gettext' 'mftrace' 'texinfo' 'fontforge' 't1utils'
 	     'gsfonts' 'texi2html')
 options=('emptydirs')
 #install=lilypond.install
-source=(http://download.linuxaudio.org/lilypond/sources/v2.16/$pkgname-$pkgver.tar.gz
-        lilypond.git-1ca9814191d16fd3c571d93035247db039254fc1.patch
-        lilypond.git-7705e46966bfa05015fb9fb20c68da844ab88028.patch)
-md5sums=('6db27f17d47e4f66a3b0716c65db3041'
-         '121ac86f1004338ae20ad55a5690c0ad'
-         'fa5073506f0e4dd96fb1858e3a75e08e')
+source=(http://download.linuxaudio.org/lilypond/sources/v2.18/$pkgname-$pkgver.tar.gz)
+md5sums=('5696fec935c616fb437693bed477cc27')
 
 prepare() {
   cd "$srcdir/$pkgname-$pkgver"
@@ -38,8 +34,8 @@ prepare() {
   rm -rf lily/out/ python/out/
 
   # Fix build
-  patch -Np1 -i "$srcdir/lilypond.git-1ca9814191d16fd3c571d93035247db039254fc1.patch"
-  patch -Np1 -i "$srcdir/lilypond.git-7705e46966bfa05015fb9fb20c68da844ab88028.patch"
+#  patch -Np1 -i "$srcdir/lilypond.git-1ca9814191d16fd3c571d93035247db039254fc1.patch"
+#  patch -Np1 -i "$srcdir/lilypond.git-7705e46966bfa05015fb9fb20c68da844ab88028.patch"
 }
 
 build() {
diff --git a/community/minitube/PKGBUILD b/community/minitube/PKGBUILD
index 029cf3b1b..890373335 100644
--- a/community/minitube/PKGBUILD
+++ b/community/minitube/PKGBUILD
@@ -1,9 +1,9 @@
-# $Id: PKGBUILD 97545 2013-09-23 20:44:05Z speps $
+# $Id: PKGBUILD 103290 2014-01-02 16:08:02Z speps $
 # Maintainer : speps <speps at aur dot archlinux dot org>
 # Contributor: Andrea Scarpino <andrea@archlinux.org>
 
 pkgname=minitube
-pkgver=2.1.3
+pkgver=2.1.5
 pkgrel=1
 pkgdesc="A native YouTube client in Qt. Watch YouTube videos without Flash Player"
 arch=('i686' 'x86_64')
@@ -11,8 +11,16 @@ url='http://flavio.tordini.org/minitube'
 license=('GPL3')
 depends=('phonon')
 install="$pkgname.install"
-source=("http://flavio.tordini.org/files/$pkgname/$pkgname-$pkgver.tar.gz")
-md5sums=('b43df4358de2e170d7e22370b39bd1ec')
+source=("http://flavio.tordini.org/files/$pkgname/$pkgname-$pkgver.tar.gz"
+        "$pkgname-missing-locale.patch")
+md5sums=('e52933f3ae5200f83aa39ac71ac13bfb'
+         '70cdaa1d3df700cf90243be5a0d55443')
+
+prepare() {
+  cd $pkgname
+  # remove missing translations
+  patch -p1 -i ../${source[1]}
+}
 
 build() {
   cd $pkgname
diff --git a/community/minitube/minitube-missing-locale.patch b/community/minitube/minitube-missing-locale.patch
new file mode 100644
index 000000000..5288120e4
--- /dev/null
+++ b/community/minitube/minitube-missing-locale.patch
@@ -0,0 +1,12 @@
+diff -aur minitube/locale/locale.pri minitube.patched/locale/locale.pri
+--- minitube/locale/locale.pri	2013-12-19 00:37:27.000000000 +0100
++++ minitube.patched/locale/locale.pri	2013-12-25 00:03:56.783943888 +0100
+@@ -4,7 +4,7 @@
+ DEPENDPATH += $$PWD
+ 
+ # ls -1 *.ts | tr '\n' ' '
+-TRANSLATIONS += ar.ts ast.ts be.ts bg_BG.ts ca.ts ca_ES.ts cs_CZ.ts da.ts de_DE.ts el.ts en.ts es.ts es_AR.ts es_ES.ts es_MX.ts fi.ts fi_FI.ts fr.ts gl.ts he_IL.ts hr.ts hu.ts ia.ts it.ts ja_JP.ts ky.ts ms_MY.ts nb.ts nl.ts pl.ts pl_PL.ts pt.ts pt_BR.ts ro.ts ru.ts sk.ts sl.ts sq.ts sv_SE.ts tr.ts uk.ts uk_UA.ts vi.ts zh_CN.ts zh_TW.ts 
++TRANSLATIONS += ar.ts ast.ts bg_BG.ts ca.ts cs_CZ.ts da.ts de_DE.ts el.ts en.ts es.ts es_AR.ts es_ES.ts fi.ts fi_FI.ts fr.ts gl.ts he_IL.ts hu.ts ia.ts it.ts ja_JP.ts ky.ts ms_MY.ts nb.ts nl.ts pl.ts pl_PL.ts pt_BR.ts ro.ts ru.ts sk.ts sl.ts sq.ts sv_SE.ts tr.ts uk.ts uk_UA.ts zh_CN.ts zh_TW.ts 
+ isEmpty(QMAKE_LRELEASE) {
+     win32:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]\lrelease.exe
+     else:QMAKE_LRELEASE = $$[QT_INSTALL_BINS]/lrelease
diff --git a/community/mpv/PKGBUILD b/community/mpv/PKGBUILD
index 39e1bd0c1..8f1703791 100644
--- a/community/mpv/PKGBUILD
+++ b/community/mpv/PKGBUILD
@@ -1,10 +1,10 @@
-# $Id: PKGBUILD 103267 2014-01-01 22:33:16Z bpiotrowski $
+# $Id: PKGBUILD 103275 2014-01-02 08:50:55Z bpiotrowski $
 # Maintainer:  Bartłomiej Piotrowski <nospam@bpiotrowski.pl>
 # Contributor: Eivind Uggedal <eivind@uggedal.com>
 
 pkgname=mpv
 pkgver=0.3.1
-pkgrel=1
+pkgrel=2
 pkgdesc='Video player based on MPlayer/mplayer2'
 arch=('i686' 'x86_64')
 license=('GPL')
@@ -17,8 +17,15 @@ depends=(
 makedepends=('mesa' 'python-docutils' 'waf')
 options=('!emptydirs' '!buildflags')
 install=mpv.install
-source=(https://github.com/mpv-player/$pkgname/archive/v$pkgver.tar.gz)
-md5sums=('f7e4091eb9ce058ce35b4bc1b6c4f3a2')
+source=(https://github.com/mpv-player/$pkgname/archive/v$pkgver.tar.gz
+        mpv-0.3.1-always_respect_sector_size.patch)
+md5sums=('f7e4091eb9ce058ce35b4bc1b6c4f3a2'
+         'afe01937e9bff1f241d37774eda39b7a')
+
+prepare() {
+  cd $pkgname-$pkgver
+  patch -p1 -i ../mpv-0.3.1-always_respect_sector_size.patch
+}
 
 build() {
   cd $pkgname-$pkgver
diff --git a/community/mpv/mpv-0.3.1-always_respect_sector_size.patch b/community/mpv/mpv-0.3.1-always_respect_sector_size.patch
new file mode 100644
index 000000000..82c474081
--- /dev/null
+++ b/community/mpv/mpv-0.3.1-always_respect_sector_size.patch
@@ -0,0 +1,34 @@
+From b04b48fc10dabb1d1b26ff519f55dcafb320985e Mon Sep 17 00:00:00 2001
+From: wm4 <wm4@nowhere>
+Date: Thu, 2 Jan 2014 00:39:14 +0100
+Subject: [PATCH] stream: always respect sector_size, fixes cdda://
+
+Streams like CDDA have special requirements in what quantities data can
+be read: you can only read a sector at once, not more and not less. The
+stream_peek() function didn't respect that and set less (used internal
+buffer size of 2048 bytes, instead of CD sector size of 2352 bytes), so
+no data was read and EOF was accidentally set, making playback with
+cdda:// fail.
+
+This is a regression since commit 9a723f, but that commit merely exposed
+the issue (the redundant seek would clear the EOF flag).
+---
+ stream/stream.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/stream/stream.c b/stream/stream.c
+index 3332e66..b48de57 100644
+--- a/stream/stream.c
++++ b/stream/stream.c
+@@ -562,7 +562,7 @@ struct bstr stream_peek(stream_t *s, int len)
+         while (buf_valid < len) {
+             int chunk = MPMAX(len - buf_valid, STREAM_BUFFER_SIZE);
+             if (s->sector_size)
+-                chunk = STREAM_BUFFER_SIZE;
++                chunk = s->sector_size;
+             assert(buf_valid + chunk <= TOTAL_BUFFER_SIZE);
+             int read = stream_read_unbuffered(s, &s->buffer[buf_valid], chunk);
+             if (read == 0)
+-- 
+1.8.5.1
+
diff --git a/community/pymol/PKGBUILD b/community/pymol/PKGBUILD
index 352ea5f1c..aa1d7a270 100644
--- a/community/pymol/PKGBUILD
+++ b/community/pymol/PKGBUILD
@@ -1,10 +1,11 @@
+# $Id: PKGBUILD 103273 2014-01-02 00:34:19Z arcanis $
 # Maintainer: Evgeniy Alekseev <arcanis dot arch at gmail dot com>
 # Contributor: graysky
 # Contributor: Tomasz Żok <tomasz dot zok at gmail dot com>
 
 pkgname=pymol
 pkgver=1.6.0.0
-pkgrel=2
+pkgrel=3
 pkgdesc="A USER-SPONSORED molecular visualization system on an OPEN-SOURCE foundation"
 arch=('i686' 'x86_64')
 url="http://pymol.org/"
@@ -15,7 +16,12 @@ md5sums=('6f5db5beea7497f5a414c8e0cf1ae53d')
 
 prepare() {
   # suppress non-zero exit code that breaks makepkg
-  sed -i '/sys.exit/ s,2,0,' "${srcdir}/${pkgname}/setup.py"
+  sed -i '/sys.exit/ s,2,0,' "${srcdir}/pymol/setup.py"
+  # change python to python2
+  sed -i "s|python|python2|g" "${srcdir}/pymol/test/cyg"
+  sed -i "s|python|python2|g" "${srcdir}/pymol/test/run"
+  sed -i "s|python|python2|g" "${srcdir}/pymol/test/show"
+  sed -i "s|python|python2|g" "${srcdir}/pymol/modules/pmg_tk/startup/apbs_tools.py"
 }
 
 build() {
@@ -26,16 +32,8 @@ build() {
 package() {
   cd "${srcdir}/${pkgname}"
   python2 setup.py install --prefix="usr/" --root="${pkgdir}"
-  
   sed -i "s|${pkgdir}||g" pymol
   install -D -m755 "pymol" "${pkgdir}/usr/bin/pymol"
-  
-  # change python to python2
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/pymol/pymol_path/test/run"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/pymol/pymol_path/test/cyg"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/pmg_tk/startup/apbs_tools.py"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/pymol/pymol_path/test/show"
-  
   install -D -m644 "LICENSE" "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE"
 }
 
diff --git a/community/python-pmw/PKGBUILD b/community/python-pmw/PKGBUILD
index dd43ef0b5..1e19d7f2b 100644
--- a/community/python-pmw/PKGBUILD
+++ b/community/python-pmw/PKGBUILD
@@ -1,3 +1,4 @@
+# $Id: PKGBUILD 103272 2014-01-02 00:34:07Z arcanis $
 # Maintainer: Evgeniy Alekseev <arcanis dot arch at gmail dot com>
 # Contributor: kfgz <kfgz at interia pl>
 # Contributor: Michael Krauss <hippodriver at gmx dot net>
@@ -5,7 +6,7 @@
 
 pkgname=python-pmw
 pkgver=1.3.3b
-pkgrel=2
+pkgrel=3
 pkgdesc="A toolkit for high-level compound widgets in Python using the Tkinter module"
 arch=('i686' 'x86_64')
 url="http://pmw.sourceforge.net/doc/index.html"
@@ -16,16 +17,17 @@ source=(${pkgname}-${pkgver}.tar.gz::http://sourceforge.net/projects/pmw/files/P
 md5sums=('d8b998b921584db32a5eeeddc6bc606c'
          '28b047a148c1780eddcf4bed6b150123')
 
+prepare() {
+  # change python to python2
+  sed -i "s|python|python2|g" "${srcdir}/Pmw/Pmw/Pmw_1_3_3/tests/ManualTests.py"
+  sed -i "s|python|python2|g" "${srcdir}/Pmw/Pmw/Pmw_1_3_3/demos/All.py"
+  sed -i "s|python|python2|g" "${srcdir}/Pmw/Pmw/Pmw_1_3_3/tests/All.py"
+  sed -i "s|python|python2|g" "${srcdir}/Pmw/Pmw/Pmw_1_3_3/bin/bundlepmw.py"
+}
+
 package() {
   cd "Pmw"
   python2 setup.py build
   python2 setup.py install --prefix=/usr --root="${pkgdir}"
-  
-  # change python to python2
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/Pmw/Pmw_1_3_3/tests/ManualTests.py"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/Pmw/Pmw_1_3_3/demos/All.py"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/Pmw/Pmw_1_3_3/tests/All.py"
-  sed -i "s|python|python2|g" "${pkgdir}/usr/lib/python2.7/site-packages/Pmw/Pmw_1_3_3/bin/bundlepmw.py"
-  
   install -D -m644 "${srcdir}/LICENSE.txt" "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE"
 }
diff --git a/community/qtractor/PKGBUILD b/community/qtractor/PKGBUILD
index ccd1df61a..3ef2d1fa2 100644
--- a/community/qtractor/PKGBUILD
+++ b/community/qtractor/PKGBUILD
@@ -1,9 +1,9 @@
-# $Id: PKGBUILD 98346 2013-10-08 20:19:08Z schiv $
+# $Id: PKGBUILD 103286 2014-01-02 13:32:26Z schiv $
 # Maintainer: Ray Rashif <schiv@archlinux.org>
 # Contributor: Philipp Überbacher <hollunder at gmx dot at>
 
 pkgname=qtractor
-pkgver=0.5.11
+pkgver=0.5.12
 pkgrel=1
 pkgdesc="Audio/MIDI multitrack sequencer"
 arch=('i686' 'x86_64')
@@ -15,7 +15,7 @@ makedepends=('ladspa' 'dssi')
 [ "$CARCH" = "i686" ] && optdepends=('dssi-vst: win32 VST support')
 install=qtractor.install
 source=("http://downloads.sourceforge.net/$pkgname/$pkgname-$pkgver.tar.gz")
-md5sums=('97a07f55ea61747859b1fd6c284a0806')
+md5sums=('f26691f70c4cd4b89bc4369a579f291f')
 
 build() {
   cd "$srcdir/$pkgname-$pkgver"
diff --git a/community/virtualgl/PKGBUILD b/community/virtualgl/PKGBUILD
index b8995d563..e4e750f51 100644
--- a/community/virtualgl/PKGBUILD
+++ b/community/virtualgl/PKGBUILD
@@ -3,8 +3,8 @@
 # Contributor: Andres Jimenez
 
 pkgname=virtualgl
-pkgver=2.3.2
-pkgrel=4
+pkgver=2.3.3
+pkgrel=1
 pkgdesc="Redirects 3D commands from an OpenGL application onto a server-side 3D graphics card"
 arch=('i686' 'x86_64')
 url="http://virtualgl.org"
@@ -12,7 +12,7 @@ license=('LGPL')
 depends=('libxv' 'glu' 'libjpeg-turbo')
 makedepends=('cmake' 'mesa')
 source=("http://downloads.sourceforge.net/project/virtualgl/VirtualGL/$pkgver/VirtualGL-$pkgver.tar.gz")
-sha1sums=('f042862c21ceaba57c6e1f0ec72adb4f838725e9')
+sha1sums=('7128fc546f0bc65a74296e19d474e52d41acbf47')
  
 build() {
   cd "$srcdir/VirtualGL-$pkgver"