]> git.saurik.com Git - apple/libc.git/commitdiff
Libc-391.4.3.tar.gz mac-os-x-1047x86 v391.4.3
authorApple <opensource@apple.com>
Fri, 11 Aug 2006 20:54:19 +0000 (20:54 +0000)
committerApple <opensource@apple.com>
Fri, 11 Aug 2006 20:54:19 +0000 (20:54 +0000)
db/hash/FreeBSD/hash_page.c.patch
gdtoa/FreeBSD/_hdtoa.c
gdtoa/FreeBSD/_hdtoa.c.patch
i386/sys/commpage.c
nls/FreeBSD/msgcat.c.patch
stdlib/FreeBSD/grantpt.c.patch

index 807837c40fa419cfa80d6e209e09a43906068d72..64d1390d51ecc838a33d03c464850feb9a380e4f 100644 (file)
@@ -1,5 +1,5 @@
---- hash_page.c.orig   Thu Mar 21 14:46:26 2002
-+++ hash_page.c        Sat Oct 18 18:31:10 2003
+--- hash_page.c.orig   2006-04-22 23:04:55.000000000 -0700
++++ hash_page.c        2006-04-23 00:23:46.000000000 -0700
 @@ -74,7 +74,7 @@
  #include <db.h>
  #include "hash.h"
 @@ -74,7 +74,7 @@
  #include <db.h>
  #include "hash.h"
@@ -9,3 +9,39 @@
  
  static u_int32_t      *fetch_bitmap(HTAB *, int);
  static u_int32_t       first_free(u_int32_t);
  
  static u_int32_t      *fetch_bitmap(HTAB *, int);
  static u_int32_t       first_free(u_int32_t);
+@@ -586,7 +586,7 @@
+       int is_bucket, is_bitmap;
+ {
+       int fd, page, size;
+-      int wsize;
++      int wsize, max;
+       size = hashp->BSIZE;
+       if ((hashp->fp == -1) && open_temp(hashp))
+@@ -595,7 +595,6 @@
+       if (hashp->LORDER != BYTE_ORDER) {
+               int i;
+-              int max;
+               if (is_bitmap) {
+                       max = hashp->BSIZE >> 2;        /* divide by 4 */
+@@ -619,6 +618,18 @@
+               errno = EFTYPE;
+               return (-1);
+       }
++      /* 4485533 - reswap the in-memory copy */
++      if (hashp->LORDER != BYTE_ORDER) {
++              int i;
++
++              if (is_bitmap) {
++                      for (i = 0; i < max; i++)
++                              M_32_SWAP(((int *)p)[i]);
++              } else {
++                      for (i = 0; i <= max; i++)
++                              M_16_SWAP(((u_int16_t *)p)[i]);
++              }
++      }
+       return (0);
+ }
index 1a8598630f84e86c4727fd152635c62058411f29..77e99ac3e2331d74870f1aba8e5e188e00cbbe97 100644 (file)
@@ -1,5 +1,5 @@
 /*-
 /*-
- * Copyright (c) 2004 David Schultz <das@FreeBSD.ORG>
+ * Copyright (c) 2004, 2005 David Schultz <das@FreeBSD.ORG>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  */
 
 #include <sys/cdefs.h>
  */
 
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: src/lib/libc/gdtoa/_hdtoa.c,v 1.2 2004/01/21 04:51:50 grehan Exp $");
+__FBSDID("$FreeBSD: src/lib/libc/gdtoa/_hdtoa.c,v 1.3 2005/01/18 18:44:07 das Exp $");
 
 #include <float.h>
 
 #include <float.h>
-#include <inttypes.h>
 #include <limits.h>
 #include <math.h>
 #include <limits.h>
 #include <math.h>
-#include <stdlib.h>
 #include "fpmath.h"
 #include "gdtoaimp.h"
 
 #include "fpmath.h"
 #include "gdtoaimp.h"
 
@@ -39,51 +37,8 @@ __FBSDID("$FreeBSD: src/lib/libc/gdtoa/_hdtoa.c,v 1.2 2004/01/21 04:51:50 grehan
 #define        INFSTR  "Infinity"
 #define        NANSTR  "NaN"
 
 #define        INFSTR  "Infinity"
 #define        NANSTR  "NaN"
 
-#define        DBL_BIAS        (DBL_MAX_EXP - 1)
-#define        LDBL_BIAS       (LDBL_MAX_EXP - 1)
-
-#ifdef LDBL_IMPLICIT_NBIT
-#define        LDBL_NBIT_ADJ   0
-#else
-#define        LDBL_NBIT_ADJ   1
-#endif
-
-/*
- * Efficiently compute the log2 of an integer.  Uses a combination of
- * arcane tricks found in fortune and arcane tricks not (yet) in
- * fortune.  This routine behaves similarly to fls(9).
- */
-static int
-log2_32(uint32_t n)
-{
-
-        n |= (n >> 1);
-        n |= (n >> 2);
-        n |= (n >> 4);
-        n |= (n >> 8);
-        n |= (n >> 16);
-
-       n = (n & 0x55555555) + ((n & 0xaaaaaaaa) >> 1);
-       n = (n & 0x33333333) + ((n & 0xcccccccc) >> 2);
-       n = (n & 0x0f0f0f0f) + ((n & 0xf0f0f0f0) >> 4);
-       n = (n & 0x00ff00ff) + ((n & 0xff00ff00) >> 8);
-       n = (n & 0x0000ffff) + ((n & 0xffff0000) >> 16);
-       return (n - 1);
-}
-
-#if (LDBL_MANH_SIZE > 32 || LDBL_MANL_SIZE > 32)
-
-static int
-log2_64(uint64_t n)
-{
-
-       if (n >> 32 != 0)
-               return (log2_32((uint32_t)(n >> 32)) + 32);
-       else
-               return (log2_32((uint32_t)n));
-}
-
-#endif /* (LDBL_MANH_SIZE > 32 || LDBL_MANL_SIZE > 32) */
+#define        DBL_ADJ         (DBL_MAX_EXP - 2 + ((DBL_MANT_DIG - 1) % 4))
+#define        LDBL_ADJ        (LDBL_MAX_EXP - 2 + ((LDBL_MANT_DIG - 1) % 4))
 
 /*
  * Round up the given digit string.  If the digit string is fff...f,
 
 /*
  * Round up the given digit string.  If the digit string is fff...f,
@@ -168,46 +123,24 @@ char *
 __hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign,
     char **rve)
 {
 __hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign,
     char **rve)
 {
+       static const int sigfigs = (DBL_MANT_DIG + 3) / 4;
        union IEEEd2bits u;
        char *s, *s0;
        int bufsize;
        union IEEEd2bits u;
        char *s, *s0;
        int bufsize;
-       int impnbit;    /* implicit normalization bit */
-       int pos;
-       int shift;      /* for subnormals, # of shifts required to normalize */
-       int sigfigs;    /* number of significant hex figures in result */
 
        u.d = d;
        *sign = u.bits.sign;
 
        switch (fpclassify(d)) {
        case FP_NORMAL:
 
        u.d = d;
        *sign = u.bits.sign;
 
        switch (fpclassify(d)) {
        case FP_NORMAL:
-               sigfigs = (DBL_MANT_DIG + 3) / 4;
-               impnbit = 1 << ((DBL_MANT_DIG - 1) % 4);
-               *decpt = u.bits.exp - DBL_BIAS + 1 -
-                   ((DBL_MANT_DIG - 1) % 4);
+               *decpt = u.bits.exp - DBL_ADJ;
                break;
        case FP_ZERO:
                *decpt = 1;
                return (nrv_alloc("0", rve, 1));
        case FP_SUBNORMAL:
                break;
        case FP_ZERO:
                *decpt = 1;
                return (nrv_alloc("0", rve, 1));
        case FP_SUBNORMAL:
-               /*
-                * The position of the highest-order bit tells us by
-                * how much to adjust the exponent (decpt).  The
-                * adjustment is raised to the next nibble boundary
-                * since we will later choose the leftmost hexadecimal
-                * digit so that all subsequent digits align on nibble
-                * boundaries.
-                */
-               if (u.bits.manh != 0) {
-                       pos = log2_32(u.bits.manh);
-                       shift = DBL_MANH_SIZE - pos;
-               } else {
-                       pos = log2_32(u.bits.manl);
-                       shift = DBL_MANH_SIZE + DBL_MANL_SIZE - pos;
-               }
-               sigfigs = (3 + DBL_MANT_DIG - shift) / 4;
-               impnbit = 0;
-               *decpt = DBL_MIN_EXP - ((shift + 3) & ~(4 - 1));
+               u.d *= 0x1p514;
+               *decpt = u.bits.exp - (514 + DBL_ADJ);
                break;
        case FP_INFINITE:
                *decpt = INT_MAX;
                break;
        case FP_INFINITE:
                *decpt = INT_MAX;
@@ -254,11 +187,9 @@ __hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign,
         * At this point, we have snarfed all the bits in the
         * mantissa, with the possible exception of the highest-order
         * (partial) nibble, which is dealt with by the next
         * At this point, we have snarfed all the bits in the
         * mantissa, with the possible exception of the highest-order
         * (partial) nibble, which is dealt with by the next
-        * statement.  That nibble is usually in manh, but it could be
-        * in manl instead for small subnormals.  We also tack on the
-        * implicit normalization bit if appropriate.
+        * statement.  We also tack on the implicit normalization bit.
         */
         */
-       *s = u.bits.manh | u.bits.manl | impnbit;
+       *s = u.bits.manh | (1U << ((DBL_MANT_DIG - 1) % 4));
 
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {
 
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {
@@ -283,71 +214,29 @@ __hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign,
 
 /*
  * This is the long double version of __hdtoa().
 
 /*
  * This is the long double version of __hdtoa().
- *
- * On architectures that have an explicit integer bit, unnormals and
- * pseudo-denormals cause problems in the conversion routine, so they
- * are ``fixed'' by effectively toggling the integer bit.  Although
- * this is not correct behavior, the hardware will not produce these
- * formats externally.
  */
 char *
 __hldtoa(long double e, const char *xdigs, int ndigits, int *decpt, int *sign,
     char **rve)
 {
  */
 char *
 __hldtoa(long double e, const char *xdigs, int ndigits, int *decpt, int *sign,
     char **rve)
 {
+       static const int sigfigs = (LDBL_MANT_DIG + 3) / 4;
        union IEEEl2bits u;
        char *s, *s0;
        int bufsize;
        union IEEEl2bits u;
        char *s, *s0;
        int bufsize;
-       int impnbit;    /* implicit normalization bit */
-       int pos;
-       int shift;      /* for subnormals, # of shifts required to normalize */
-       int sigfigs;    /* number of significant hex figures in result */
 
        u.e = e;
        *sign = u.bits.sign;
 
        switch (fpclassify(e)) {
        case FP_NORMAL:
 
        u.e = e;
        *sign = u.bits.sign;
 
        switch (fpclassify(e)) {
        case FP_NORMAL:
-               sigfigs = (LDBL_MANT_DIG + 3) / 4;
-               impnbit = 1 << ((LDBL_MANT_DIG - 1) % 4);
-               *decpt = u.bits.exp - LDBL_BIAS + 1 -
-                   ((LDBL_MANT_DIG - 1) % 4);
+               *decpt = u.bits.exp - LDBL_ADJ;
                break;
        case FP_ZERO:
                *decpt = 1;
                return (nrv_alloc("0", rve, 1));
        case FP_SUBNORMAL:
                break;
        case FP_ZERO:
                *decpt = 1;
                return (nrv_alloc("0", rve, 1));
        case FP_SUBNORMAL:
-               /*
-                * The position of the highest-order bit tells us by
-                * how much to adjust the exponent (decpt).  The
-                * adjustment is raised to the next nibble boundary
-                * since we will later choose the leftmost hexadecimal
-                * digit so that all subsequent digits align on nibble
-                * boundaries.
-                */
-#ifdef LDBL_IMPLICIT_NBIT
-               /* Don't trust the normalization bit to be off. */
-               u.bits.manh &= ~(~0ULL << (LDBL_MANH_SIZE - 1));
-#endif
-               if (u.bits.manh != 0) {
-#if LDBL_MANH_SIZE > 32
-                       pos = log2_64(u.bits.manh);
-#else
-                       pos = log2_32(u.bits.manh);
-#endif
-                       shift = LDBL_MANH_SIZE - LDBL_NBIT_ADJ - pos;
-               } else {
-#if LDBL_MANL_SIZE > 32
-                       pos = log2_64(u.bits.manl);
-#else
-                       pos = log2_32(u.bits.manl);
-#endif
-                       shift = LDBL_MANH_SIZE + LDBL_MANL_SIZE -
-                           LDBL_NBIT_ADJ - pos;
-               }
-               sigfigs = (3 + LDBL_MANT_DIG - LDBL_NBIT_ADJ - shift) / 4;
-               *decpt = LDBL_MIN_EXP + LDBL_NBIT_ADJ -
-                   ((shift + 3) & ~(4 - 1));
-               impnbit = 0;
+               u.e *= 0x1p514L;
+               *decpt = u.bits.exp - (514 + LDBL_ADJ);
                break;
        case FP_INFINITE:
                *decpt = INT_MAX;
                break;
        case FP_INFINITE:
                *decpt = INT_MAX;
@@ -394,11 +283,9 @@ __hldtoa(long double e, const char *xdigs, int ndigits, int *decpt, int *sign,
         * At this point, we have snarfed all the bits in the
         * mantissa, with the possible exception of the highest-order
         * (partial) nibble, which is dealt with by the next
         * At this point, we have snarfed all the bits in the
         * mantissa, with the possible exception of the highest-order
         * (partial) nibble, which is dealt with by the next
-        * statement.  That nibble is usually in manh, but it could be
-        * in manl instead for small subnormals.  We also tack on the
-        * implicit normalization bit if appropriate.
+        * statement.  We also tack on the implicit normalization bit.
         */
         */
-       *s = u.bits.manh | u.bits.manl | impnbit;
+       *s = u.bits.manh | (1U << ((LDBL_MANT_DIG - 1) % 4));
 
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {
 
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {
index 5b4d7cf0f69521a9d32d39ddaedd6f6b2a85f5eb..de6da95e2c91bed27957fa3e057c09d0b7657b3a 100644 (file)
@@ -1,86 +1,17 @@
---- _hdtoa.c.orig      2004-06-03 15:22:08.000000000 -0700
-+++ _hdtoa.c   2004-08-28 17:10:21.000000000 -0700
-@@ -32,6 +32,9 @@
- #include <limits.h>
- #include <math.h>
- #include <stdlib.h>
-+#ifdef LDBL_HEAD_TAIL_PAIR
-+#include <alloca.h>
-+#endif /* LDBL_HEAD_TAIL_PAIR */
- #include "fpmath.h"
- #include "gdtoaimp.h"
-@@ -301,16 +304,31 @@
-       int pos;
-       int shift;      /* for subnormals, # of shifts required to normalize */
-       int sigfigs;    /* number of significant hex figures in result */
+--- _hdtoa.c.orig      2006-01-31 15:21:41.000000000 -0800
++++ _hdtoa.c   2006-01-31 23:37:12.000000000 -0800
+@@ -223,6 +223,10 @@
+       union IEEEl2bits u;
+       char *s, *s0;
+       int bufsize;
 +#ifdef LDBL_HEAD_TAIL_PAIR
 +      uint32_t bits[4];
 +#ifdef LDBL_HEAD_TAIL_PAIR
 +      uint32_t bits[4];
-+      int i;
++      int i, pos;
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        u.e = e;
        *sign = u.bits.sign;
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        u.e = e;
        *sign = u.bits.sign;
-+#ifdef LDBL_HEAD_TAIL_PAIR
-+      switch (__fpclassifyd(u.d[0])) {
-+#else /* LDBL_HEAD_TAIL_PAIR */
-       switch (fpclassify(e)) {
-+#endif /* LDBL_HEAD_TAIL_PAIR */
-       case FP_NORMAL:
-+#ifdef LDBL_HEAD_TAIL_PAIR
-               sigfigs = (LDBL_MANT_DIG + 3) / 4;
-               impnbit = 1 << ((LDBL_MANT_DIG - 1) % 4);
-               *decpt = u.bits.exp - LDBL_BIAS + 1 -
-                   ((LDBL_MANT_DIG - 1) % 4);
-+#else /* LDBL_HEAD_TAIL_PAIR */
-+              sigfigs = (LDBL_MANT_DIG + 3) / 4;
-+              impnbit = 1 << ((LDBL_MANT_DIG - 1) % 4);
-+              *decpt = u.bits.exp - LDBL_BIAS + 1 -
-+                  ((LDBL_MANT_DIG - 1) % 4);
-+#endif /* LDBL_HEAD_TAIL_PAIR */
-               break;
-       case FP_ZERO:
-               *decpt = 1;
-@@ -328,13 +346,26 @@
-               /* Don't trust the normalization bit to be off. */
-               u.bits.manh &= ~(~0ULL << (LDBL_MANH_SIZE - 1));
- #endif
-+#ifndef LDBL_HEAD_TAIL_PAIR
-               if (u.bits.manh != 0) {
-+#endif /* LDBL_HEAD_TAIL_PAIR */
- #if LDBL_MANH_SIZE > 32
-                       pos = log2_64(u.bits.manh);
- #else
-                       pos = log2_32(u.bits.manh);
- #endif
-                       shift = LDBL_MANH_SIZE - LDBL_NBIT_ADJ - pos;
-+#ifdef LDBL_HEAD_TAIL_PAIR
-+              sigfigs = (3 + LDBL_MANT_DIG - LDBL_NBIT_ADJ - shift) / 4;
-+              // we use DBL_MIN_EXP below because the head double is
-+              // subnormal (and the tail double is zero)
-+              *decpt = DBL_MIN_EXP + LDBL_NBIT_ADJ;
-+              pos = (LDBL_MANT_DIG + 3) % 4;
-+              if (pos < shift)
-+                      *decpt -= pos + ((shift - pos + 3) & ~(4 - 1));
-+              else
-+                      *decpt -= shift;
-+#else /* LDBL_HEAD_TAIL_PAIR */
-               } else {
- #if LDBL_MANL_SIZE > 32
-                       pos = log2_64(u.bits.manl);
-@@ -345,8 +376,9 @@
-                           LDBL_NBIT_ADJ - pos;
-               }
-               sigfigs = (3 + LDBL_MANT_DIG - LDBL_NBIT_ADJ - shift) / 4;
--              *decpt = LDBL_MIN_EXP + LDBL_NBIT_ADJ -
-+              *decpt = DBL_MIN_EXP + LDBL_NBIT_ADJ -
-                   ((shift + 3) & ~(4 - 1));
-+#endif /* LDBL_HEAD_TAIL_PAIR */
-               impnbit = 0;
-               break;
-       case FP_INFINITE:
-@@ -381,6 +413,19 @@
+@@ -270,6 +274,19 @@
         */
        for (s = s0 + bufsize - 1; s > s0 + sigfigs - 1; s--)
                *s = 0;
         */
        for (s = s0 + bufsize - 1; s > s0 + sigfigs - 1; s--)
                *s = 0;
        for (; s > s0 + sigfigs - (LDBL_MANL_SIZE / 4) - 1 && s > s0; s--) {
                *s = u.bits.manl & 0xf;
                u.bits.manl >>= 4;
        for (; s > s0 + sigfigs - (LDBL_MANL_SIZE / 4) - 1 && s > s0; s--) {
                *s = u.bits.manl & 0xf;
                u.bits.manl >>= 4;
-@@ -389,6 +434,7 @@
+@@ -278,6 +295,7 @@
                *s = u.bits.manh & 0xf;
                u.bits.manh >>= 4;
        }
                *s = u.bits.manh & 0xf;
                u.bits.manh >>= 4;
        }
  
        /*
         * At this point, we have snarfed all the bits in the
  
        /*
         * At this point, we have snarfed all the bits in the
-@@ -398,7 +444,11 @@
-        * in manl instead for small subnormals.  We also tack on the
-        * implicit normalization bit if appropriate.
+@@ -285,7 +303,11 @@
+        * (partial) nibble, which is dealt with by the next
+        * statement.  We also tack on the implicit normalization bit.
         */
 +#ifdef LDBL_HEAD_TAIL_PAIR
         */
 +#ifdef LDBL_HEAD_TAIL_PAIR
-+      *s = bits[i] | impnbit;
++      *s = bits[i];
 +#else /* LDBL_HEAD_TAIL_PAIR */
 +#else /* LDBL_HEAD_TAIL_PAIR */
-       *s = u.bits.manh | u.bits.manl | impnbit;
+       *s = u.bits.manh | (1U << ((LDBL_MANT_DIG - 1) % 4));
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        /* If ndigits < 0, we are expected to auto-size the precision. */
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        /* If ndigits < 0, we are expected to auto-size the precision. */
index cec8c8ddfa7bad7eb09159c84a1abf3b16a0a240..fa1d6fe0ba92cd1efb07d958d82ee66426945ddd 100644 (file)
  * @APPLE_LICENSE_HEADER_END@
  */
 
  * @APPLE_LICENSE_HEADER_END@
  */
 
-#ifndef _OPEN_SOURCE_
-
-#define __APPLE_API_PRIVATE
-#include <machine/cpu_capabilities.h>
-#undef  __APPLE_API_PRIVATE
-
-const void* __commpage_dsmos()
-{
-       return ((const void*) _COMM_PAGE_SYSTEM_INTEGRITY);
-}
-
-#endif
index 10c11b7fe7f9747cb25b5138ca079614eee62d72..6a531ba346af2f40594e63d0a32cfed4d42a86a2 100644 (file)
@@ -1,6 +1,6 @@
---- msgcat.c.orig      2004-11-25 11:38:30.000000000 -0800
-+++ msgcat.c   2005-02-27 12:06:52.000000000 -0800
-@@ -45,7 +45,7 @@
+--- /Network/Servers/hills/Volumes/capanna/josborne/work-area/PR-4416984/Libc/nls/FreeBSD/msgcat.c     2004-11-25 11:38:30.000000000 -0800
++++ msgcat.c   2006-02-21 12:46:25.000000000 -0800
+@@ -45,16 +45,23 @@
  #include <errno.h>
  #include <fcntl.h>
  #include <limits.h>
  #include <errno.h>
  #include <fcntl.h>
  #include <limits.h>
@@ -9,16 +9,24 @@
  #include <nl_types.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <nl_types.h>
  #include <stdio.h>
  #include <stdlib.h>
-@@ -54,7 +54,7 @@
+ #include <string.h>
+ #include <unistd.h>
++#include <machine/endian.h>
++#include <libkern/OSByteOrder.h>
  #include "un-namespace.h"
  
  #include "msgcat.h"
 -#include "../locale/setlocale.h"        /* for ENCODING_LEN */
 +#include "setlocale.h"        /* for ENCODING_LEN */
  #include "un-namespace.h"
  
  #include "msgcat.h"
 -#include "../locale/setlocale.h"        /* for ENCODING_LEN */
 +#include "setlocale.h"        /* for ENCODING_LEN */
++
++#ifndef htonll
++#define htonll(x) OSSwapHostToBigInt64(x)
++#define ntohll(x) OSSwapBigToHostInt64(x)
++#endif
  
  #define _DEFAULT_NLS_PATH "/usr/share/nls/%L/%N.cat:/usr/share/nls/%N/%L:/usr/local/share/nls/%L/%N.cat:/usr/local/share/nls/%N/%L"
  
  
  #define _DEFAULT_NLS_PATH "/usr/share/nls/%L/%N.cat:/usr/share/nls/%N/%L:/usr/local/share/nls/%L/%N.cat:/usr/local/share/nls/%N/%L"
  
-@@ -87,7 +87,7 @@
+@@ -87,7 +94,7 @@
                return (loadCat(name));
  
        if (type == NL_CAT_LOCALE)
                return (loadCat(name));
  
        if (type == NL_CAT_LOCALE)
        else
                lang = getenv("LANG");
  
        else
                lang = getenv("LANG");
  
+@@ -210,21 +217,21 @@
+ #define LOOKUP(PARENT, CHILD, ID, NUM, SET) {                    \
+       lo = 0;                                                  \
+-      if (ID - 1 < PARENT->NUM) {                              \
++      if (ID - 1 < NUM) {                              \
+               cur = ID - 1;                                    \
+               hi = ID;                                         \
+       } else {                                                 \
+-              hi = PARENT->NUM;                                \
++              hi = NUM;                                \
+               cur = (hi - lo) / 2;                             \
+       }                                                        \
+       while (TRUE) {                                           \
+               CHILD = PARENT->SET + cur;                       \
+-              if (CHILD->ID == ID)                             \
++              if (htonl(CHILD->ID) == ID)                             \
+                       break;                                   \
+-              if (CHILD->ID < ID) {                            \
++              if (htonl(CHILD->ID) < ID) {                            \
+                       lo = cur + 1;                            \
+-                      if (hi > cur + (ID - CHILD->ID) + 1)     \
+-                              hi = cur + (ID - CHILD->ID) + 1; \
++                      if (hi > cur + (ID - htonl(CHILD->ID)) + 1)     \
++                              hi = cur + (ID - htonl(CHILD->ID)) + 1; \
+                       dir = 1;                                 \
+               } else {                                         \
+                       hi = cur;                                \
+@@ -240,32 +247,28 @@
+ }
+ static MCSetT *
+-MCGetSet(cat, setId)
+-      MCCatT  *cat;
+-      int     setId;
++MCGetSet(MCCatT *cat, int setId)
+ {
+       MCSetT  *set;
+       long    lo, hi, cur, dir;
+       if (cat == NULL || setId <= 0)
+               return (NULL);
+-      LOOKUP(cat, set, setId, numSets, sets);
++      LOOKUP(cat, set, setId, cat->numSets, sets);
+       if (set->invalid && loadSet(cat, set) <= 0)
+               return (NULL);
+       return (set);
+ }
+ static MCMsgT *
+-MCGetMsg(set, msgId)
+-      MCSetT  *set;
+-      int     msgId;
++MCGetMsg(MCSetT *set, int msgId)
+ {
+       MCMsgT  *msg;
+       long    lo, hi, cur, dir;
+       if (set == NULL || set->invalid || msgId <= 0)
+               return (NULL);
+-      LOOKUP(set, msg, msgId, numMsgs, u.msgs);
++      LOOKUP(set, msg, msgId, htonl(set->numMsgs), u.msgs);
+       return (msg);
+ }
+@@ -377,27 +380,30 @@
+           strncmp(header.magic, MCMagic, MCMagicLen) != 0)
+               CORRUPT();
+-      if (header.majorVer != MCMajorVer) {
++      if (htonl(header.majorVer) != MCMajorVer) {
+               (void)fclose(cat->fp);
+               free(cat);
+-              (void)fprintf(stderr, "%s: %s is version %ld, we need %ld.\n",
+-                  _errowner, catpath, header.majorVer, MCMajorVer);
++              if (OSSwapInt32(htonl(header.majorVer)) == MCMajorVer) {
++                  (void)fprintf(stderr, "%s: %s is the wrong byte ordering.\n", _errowner, catpath);
++              } else {
++                  (void)fprintf(stderr, "%s: %s is version %ld, we need %ld.\n", _errowner, catpath, htonl(header.majorVer), MCMajorVer);
++              }
+               NLRETERR(EFTYPE);
+       }
+-      if (header.numSets <= 0) {
++      if (htonl(header.numSets) <= 0) {
+               (void)fclose(cat->fp);
+               free(cat);
+               (void)fprintf(stderr, "%s: %s has %ld sets!\n",
+-                  _errowner, catpath, header.numSets);
++                  _errowner, catpath, htonl(header.numSets));
+               NLRETERR(EFTYPE);
+       }
+-      cat->numSets = header.numSets;
+-      if ((cat->sets = (MCSetT *)malloc(sizeof(MCSetT) * header.numSets)) ==
++      cat->numSets = htonl(header.numSets);
++      if ((cat->sets = (MCSetT *)malloc(sizeof(MCSetT) * cat->numSets)) ==
+           NULL)
+               NOSPACE();
+-      nextSet = header.firstSet;
++      nextSet = htonll(header.firstSet);
+       for (i = 0; i < cat->numSets; ++i) {
+               if (fseeko(cat->fp, nextSet, SEEK_SET) == -1) {
+                       __nls_free_resources(cat, i);
+@@ -414,7 +420,7 @@
+               /* if it's invalid, skip over it (and backup 'i') */
+               if (set->invalid) {
+                       --i;
+-                      nextSet = set->nextSet;
++                      nextSet = htonll(set->nextSet);
+                       continue;
+               }
+ #if 0
+@@ -432,7 +438,7 @@
+               } else
+ #endif
+                       set->invalid = TRUE;
+-              nextSet = set->nextSet;
++              nextSet = htonll(set->nextSet);
+       }
+ #if 0
+       if (cat->loadType == MCLoadAll) {
+@@ -453,11 +459,11 @@
+       int     saverr;
+       /* Get the data */
+-      if (fseeko(cat->fp, set->data.off, SEEK_SET) == -1)
++      if (fseeko(cat->fp, htonll(set->data.off), SEEK_SET) == -1)
+               return (0);
+-      if ((set->data.str = malloc(set->dataLen)) == NULL)
++      if ((set->data.str = malloc(htonl(set->dataLen))) == NULL)
+               return (-1);
+-      if (fread(set->data.str, set->dataLen, 1, cat->fp) != 1) {
++      if (fread(set->data.str, htonl(set->dataLen), 1, cat->fp) != 1) {
+               saverr = errno;
+               free(set->data.str);
+               errno = saverr;
+@@ -465,13 +471,13 @@
+       }
+       /* Get the messages */
+-      if (fseeko(cat->fp, set->u.firstMsg, SEEK_SET) == -1) {
++      if (fseeko(cat->fp, htonll(set->u.firstMsg), SEEK_SET) == -1) {
+               saverr = errno;
+               free(set->data.str);
+               errno = saverr;
+               return (0);
+       }
+-      if ((set->u.msgs = (MCMsgT *)malloc(sizeof(MCMsgT) * set->numMsgs)) ==
++      if ((set->u.msgs = (MCMsgT *)malloc(sizeof(MCMsgT) * htonl(set->numMsgs))) ==
+           NULL) {
+               saverr = errno;
+               free(set->data.str);
+@@ -479,7 +485,7 @@
+               return (-1);
+       }
+-      for (i = 0; i < set->numMsgs; ++i) {
++      for (i = 0; i < htonl(set->numMsgs); ++i) {
+               msg = set->u.msgs + i;
+               if (fread(msg, sizeof(*msg), 1, cat->fp) != 1) {
+                       saverr = errno;
+@@ -492,7 +498,7 @@
+                       --i;
+                       continue;
+               }
+-              msg->msg.str = (char *)(set->data.str + msg->msg.off);
++              msg->msg.str = (char *)(set->data.str + htonll(msg->msg.off));
+       }
+       set->invalid = FALSE;
+       return (1);
index a41355beb5dab1c269d3807f272c9e35b86ab343..2e73b704131e3357d80ff0f6249b2922cfe927ee 100644 (file)
@@ -1,5 +1,5 @@
---- grantpt.c.orig     2004-09-14 19:06:46.000000000 -0700
-+++ grantpt.c  2004-09-14 19:11:31.000000000 -0700
+--- grantpt.c.orig     2006-04-21 22:41:31.000000000 -0700
++++ grantpt.c  2006-04-21 22:43:03.000000000 -0700
 @@ -54,18 +54,16 @@
  #include <unistd.h>
  #include "un-namespace.h"
 @@ -54,18 +54,16 @@
  #include <unistd.h>
  #include "un-namespace.h"
                         minor((x).st_rdev) >= 0 &&                     \
                         minor((x).st_rdev) < PT_MAX)
  
                         minor((x).st_rdev) >= 0 &&                     \
                         minor((x).st_rdev) < PT_MAX)
  
-@@ -227,8 +246,8 @@
+@@ -100,50 +119,53 @@
+       serrno = errno;
+       if ((slave = ptsname(fildes)) != NULL) {
+-              /*
+-               * Block SIGCHLD.
+-               */
+-              (void)sigemptyset(&nblock);
+-              (void)sigaddset(&nblock, SIGCHLD);
+-              (void)_sigprocmask(SIG_BLOCK, &nblock, &oblock);
+-
+-              switch (pid = fork()) {
+-              case -1:
+-                      break;
+-              case 0:         /* child */
++              /* 4430299: if we are root, we don't need to fork/exec */
++              if (geteuid() != 0) {
+                       /*
+-                       * pt_chown expects the master pseudo TTY to be its
+-                       * standard input.
++                       * Block SIGCHLD.
+                        */
+-                      (void)_dup2(fildes, STDIN_FILENO);
+-                      (void)_sigprocmask(SIG_SETMASK, &oblock, NULL);
+-                      execl(_PATH_PTCHOWN, _PATH_PTCHOWN, (char *)NULL);
+-                      _exit(EX_UNAVAILABLE);
+-                      /* NOTREACHED */
+-              default:        /* parent */
++                      (void)sigemptyset(&nblock);
++                      (void)sigaddset(&nblock, SIGCHLD);
++                      (void)_sigprocmask(SIG_BLOCK, &nblock, &oblock);
++
++                      switch (pid = fork()) {
++                      case -1:
++                              break;
++                      case 0:         /* child */
++                              /*
++                               * pt_chown expects the master pseudo TTY to be its
++                               * standard input.
++                               */
++                              (void)_dup2(fildes, STDIN_FILENO);
++                              (void)_sigprocmask(SIG_SETMASK, &oblock, NULL);
++                              execl(_PATH_PTCHOWN, _PATH_PTCHOWN, (char *)NULL);
++                              _exit(EX_UNAVAILABLE);
++                              /* NOTREACHED */
++                      default:        /* parent */
++                              /*
++                               * Just wait for the process.  Error checking is
++                               * done below.
++                               */
++                              while ((spid = _waitpid(pid, &status, 0)) == -1 &&
++                                     (errno == EINTR))
++                                      ;
++                              if (spid != -1 && WIFEXITED(status) &&
++                                  WEXITSTATUS(status) == EX_OK)
++                                      retval = 0;
++                              else
++                                      errno = EACCES;
++                              break;
++                      }
++
+                       /*
+-                       * Just wait for the process.  Error checking is
+-                       * done below.
++                       * Restore process's signal mask.
+                        */
+-                      while ((spid = _waitpid(pid, &status, 0)) == -1 &&
+-                             (errno == EINTR))
+-                              ;
+-                      if (spid != -1 && WIFEXITED(status) &&
+-                          WEXITSTATUS(status) == EX_OK)
+-                              retval = 0;
+-                      else
+-                              errno = EACCES;
+-                      break;
++                      (void)_sigprocmask(SIG_SETMASK, &oblock, NULL);
+               }
+-              /*
+-               * Restore process's signal mask.
+-               */
+-              (void)_sigprocmask(SIG_SETMASK, &oblock, NULL);
+-
+               if (retval) {
+                       /*
+-                       * pt_chown failed.  Try to manually change the
++                       * pt_chown failed (or we're root).  Try to manually change the
+                        * permissions for the slave.
+                        */
+                       gid = (grp = getgrnam("tty")) ? grp->gr_gid : -1;
+@@ -227,8 +249,8 @@
                        errno = EINVAL;
                else {
                        (void)sprintf(slave, _PATH_DEV PTS_PREFIX "%c%c",
                        errno = EINVAL;
                else {
                        (void)sprintf(slave, _PATH_DEV PTS_PREFIX "%c%c",