-

7 files changed, 121 insertions, 54 deletions

diff --git a/src/conf_post.h b/src/conf_post.h
index 98ff12e5a53..5c332a05a5c 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -51,10 +51,21 @@ typedef bool bool_bf;
 #endif
 #endif
 
-/* When not using Clang, assume its attributes and features are absent.  */
+/* Simulate __has_attribute on compilers that lack it.  It is used only
+   on arguments like alloc_size that are handled in this simulation.  */
 #ifndef __has_attribute
-# define __has_attribute(a) false
-#endif
+# define __has_attribute(a) __has_attribute_##a
+# define __has_attribute_alloc_size (4 < __GNUC__ + (3 <= __GNUC_MINOR__))
+# define __has_attribute_cleanup (3 < __GNUC__ + (4 <= __GNUC_MINOR__))
+# define __has_attribute_externally_visible \
+    (4 < __GNUC__ + (1 <= __GNUC_MINOR__))
+# define __has_attribute_no_address_safety_analysis false
+# define __has_attribute_no_sanitize_address \
+    (4 < __GNUC__ + (8 <= __GNUC_MINOR__))
+#endif
+
+/* Simulate __has_feature on compilers that lack it.  It is used only
+   to define ADDRESS_SANITIZER below.  */
 #ifndef __has_feature
 # define __has_feature(a) false
 #endif
@@ -222,9 +233,7 @@ extern int emacs_setenv_TZ (char const *);
 #define NO_INLINE
 #endif
 
-#if (__clang__                                                          \
-     ? __has_attribute (externally_visible)                             \
-     : (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)))
+#if __has_attribute (externally_visible)
 #define EXTERNALLY_VISIBLE __attribute__((externally_visible))
 #else
 #define EXTERNALLY_VISIBLE
@@ -253,9 +262,7 @@ extern int emacs_setenv_TZ (char const *);
 # define ATTRIBUTE_MALLOC
 #endif
 
-#if (__clang__                                  \
-     ? __has_attribute (alloc_size)             \
-     : 4 < __GNUC__ + (3 <= __GNUC_MINOR__))
+#if __has_attribute (alloc_size)
 # define ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
 #else
 # define ATTRIBUTE_ALLOC_SIZE(args)
@@ -278,8 +285,7 @@ extern int emacs_setenv_TZ (char const *);
 /* Attribute of functions whose code should not have addresses
    sanitized.  */
 
-#if (__has_attribute (no_sanitize_address) \
-     || 4 < __GNUC__ + (8 <= __GNUC_MINOR__))
+#if __has_attribute (no_sanitize_address)
 # define ATTRIBUTE_NO_SANITIZE_ADDRESS \
     __attribute__ ((no_sanitize_address)) ADDRESS_SANITIZER_WORKAROUND
 #elif __has_attribute (no_address_safety_analysis)
diff --git a/src/emacs-module.c b/src/emacs-module.c
index b5e044e758f..79a077b3cb4 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -35,8 +35,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Feature tests.  */
 
-/* True if __attribute__ ((cleanup (...))) works, false otherwise.  */
-#ifdef HAVE_VAR_ATTRIBUTE_CLEANUP
+#if __has_attribute (cleanup)
 enum { module_has_cleanup = true };
 #else
 enum { module_has_cleanup = false };
diff --git a/src/fns.c b/src/fns.c
index 977229b97b7..86ad333702e 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -50,7 +50,8 @@ All integers representable in Lisp, i.e. between `most-negative-fixnum'
 and `most-positive-fixnum', inclusive, are equally likely.
 
 With positive integer LIMIT, return random number in interval [0,LIMIT).
-With argument t, set the random number seed from the current time and pid.
+With argument t, set the random number seed from the system's entropy
+pool if available, otherwise from less-random volatile data such as the time.
 With a string argument, set the seed based on the string's contents.
 Other values of LIMIT are ignored.
 
diff --git a/src/gnutls.c b/src/gnutls.c
index a1d058fcd48..01a5983d3b0 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -1112,15 +1112,17 @@ The return value is a property list with top-level keys :warnings and
 /* Initialize global GnuTLS state to defaults.
    Call `gnutls-global-deinit' when GnuTLS usage is no longer needed.
    Return zero on success.  */
-static Lisp_Object
+Lisp_Object
 emacs_gnutls_global_init (void)
 {
   int ret = GNUTLS_E_SUCCESS;
 
   if (!gnutls_global_initialized)
-    ret = gnutls_global_init ();
-
-  gnutls_global_initialized = 1;
+    {
+      ret = gnutls_global_init ();
+      if (ret == GNUTLS_E_SUCCESS)
+        gnutls_global_initialized = 1;
+    }
 
   return gnutls_make_error (ret);
 }
diff --git a/src/gnutls.h b/src/gnutls.h
index c4fe738bfa0..8e879c168bd 100644
--- a/src/gnutls.h
+++ b/src/gnutls.h
@@ -83,6 +83,7 @@ extern ptrdiff_t emacs_gnutls_record_check_pending (gnutls_session_t state);
 extern void emacs_gnutls_transport_set_errno (gnutls_session_t state, int err);
 #endif
 extern Lisp_Object emacs_gnutls_deinit (Lisp_Object);
+extern Lisp_Object emacs_gnutls_global_init (void);
 
 #endif
 
diff --git a/src/sysdep.c b/src/sysdep.c
index e73acec733e..a86b53642f2 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -99,6 +99,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "process.h"
 #include "cm.h"
 
+#include "gnutls.h"
+#if 0x020c00 <= GNUTLS_VERSION_NUMBER && !defined WINDOWSNT
+# include <gnutls/crypto.h>
+#else
+# define emacs_gnutls_global_init() Qnil
+# define gnutls_rnd(level, data, len) (-1)
+#endif
+
 #ifdef WINDOWSNT
 #include <direct.h>
 /* In process.h which conflicts with the local copy.  */
@@ -2071,36 +2079,56 @@ init_signals (bool dumping)
 # endif /* !HAVE_RANDOM */
 #endif /* !RAND_BITS */
 
+#ifdef HAVE_RANDOM
+typedef unsigned int random_seed;
+static void set_random_seed (random_seed arg) { srandom (arg); }
+#elif defined HAVE_LRAND48
+/* Although srand48 uses a long seed, this is unsigned long to avoid
+   undefined behavior on signed integer overflow in init_random.  */
+typedef unsigned long int random_seed;
+static void set_random_seed (random_seed arg) { srand48 (arg); }
+#else
+typedef unsigned int random_seed;
+static void set_random_seed (random_seed arg) { srand (arg); }
+#endif
+
 void
 seed_random (void *seed, ptrdiff_t seed_size)
 {
-#if defined HAVE_RANDOM || ! defined HAVE_LRAND48
-  unsigned int arg = 0;
-#else
-  long int arg = 0;
-#endif
+  random_seed arg = 0;
   unsigned char *argp = (unsigned char *) &arg;
   unsigned char *seedp = seed;
-  ptrdiff_t i;
-  for (i = 0; i < seed_size; i++)
+  for (ptrdiff_t i = 0; i < seed_size; i++)
     argp[i % sizeof arg] ^= seedp[i];
-#ifdef HAVE_RANDOM
-  srandom (arg);
-#else
-# ifdef HAVE_LRAND48
-  srand48 (arg);
-# else
-  srand (arg);
-# endif
-#endif
+  set_random_seed (arg);
 }
 
 void
 init_random (void)
 {
-  struct timespec t = current_timespec ();
-  uintmax_t v = getpid () ^ t.tv_sec ^ t.tv_nsec;
-  seed_random (&v, sizeof v);
+  random_seed v;
+  if (! (EQ (emacs_gnutls_global_init (), Qt)
+         && gnutls_rnd (GNUTLS_RND_NONCE, &v, sizeof v) == 0))
+    {
+      bool success = false;
+#ifndef WINDOWSNT
+      int fd = emacs_open ("/dev/urandom", O_RDONLY | O_BINARY, 0);
+      if (0 <= fd)
+        {
+          success = emacs_read (fd, &v, sizeof v) == sizeof v;
+          emacs_close (fd);
+        }
+#else
+      success = w32_init_random (&v, sizeof v) == 0;
+#endif
+      if (! success)
+        {
+          /* Fall back to current time value + PID.  */
+          struct timespec t = current_timespec ();
+          v = getpid () ^ t.tv_sec ^ t.tv_nsec;
+        }
+    }
+  set_random_seed (v);
 }
 
 /*
diff --git a/src/window.c b/src/window.c
index bb414e7d311..4aeb8b39a70 100644
--- a/src/window.c
+++ b/src/window.c
@@ -4979,27 +4979,34 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
 
   if (n > 0)
     {
+      int last_y = it.last_visible_y - this_scroll_margin - 1;
+
       /* We moved the window start towards ZV, so PT may be now
          in the scroll margin at the top.  */
       move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
-      if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin
+      if (IT_CHARPOS (it) == PT
+          && it.current_y >= this_scroll_margin
+          && it.current_y <= last_y - WINDOW_HEADER_LINE_HEIGHT (w)
           && (NILP (Vscroll_preserve_screen_position)
               || EQ (Vscroll_preserve_screen_position, Qt)))
         /* We found PT at a legitimate height.  Leave it alone.  */
         ;
-      else if (window_scroll_pixel_based_preserve_y >= 0)
-        {
-          /* If we have a header line, take account of it.
-             This is necessary because we set it.current_y to 0, above.  */
-          move_it_to (&it, -1,
-                      window_scroll_pixel_based_preserve_x,
-                      (window_scroll_pixel_based_preserve_y
-                       - WINDOW_WANTS_HEADER_LINE_P (w)),
-                      -1, MOVE_TO_Y | MOVE_TO_X);
-          SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
-        }
       else
         {
+          if (window_scroll_pixel_based_preserve_y >= 0)
+            {
+              /* Don't enter the scroll margin at the end of the window.  */
+              int goal_y = min (last_y, window_scroll_pixel_based_preserve_y);
+
+              /* If we have a header line, take account of it.  This
+                 is necessary because we set it.current_y to 0, above.  */
+              move_it_to (&it, -1,
+                          window_scroll_pixel_based_preserve_x,
+                          goal_y - WINDOW_HEADER_LINE_HEIGHT (w),
+                          -1, MOVE_TO_Y | MOVE_TO_X);
+            }
+
+          /* Get out of the scroll margin at the top of the window.  */
           while (it.current_y < this_scroll_margin)
             {
               int prev = it.current_y;
@@ -5023,7 +5030,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
       /* We moved the window start towards BEGV, so PT may be now
          in the scroll margin at the bottom.  */
       move_it_to (&it, PT, -1,
-                  (it.last_visible_y - CURRENT_HEADER_LINE_HEIGHT (w)
+                  (it.last_visible_y - WINDOW_HEADER_LINE_HEIGHT (w)
                    - this_scroll_margin - 1),
                   -1,
                   MOVE_TO_POS | MOVE_TO_Y);
@@ -5074,14 +5081,20 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
         ;
       else if (window_scroll_pixel_based_preserve_y >= 0)
         {
+          int goal_y = min (it.last_visible_y - this_scroll_margin - 1,
+                            window_scroll_pixel_based_preserve_y);
+
+          /* Don't let the preserved screen Y coordinate put us inside
+             any of the two margins.  */
+          if (goal_y < this_scroll_margin)
+            goal_y = this_scroll_margin;
           SET_TEXT_POS_FROM_MARKER (start, w->start);
           start_display (&it, w, start);
           /* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
              here because we called start_display again and did not
              alter it.current_y this time.  */
           move_it_to (&it, -1, window_scroll_pixel_based_preserve_x,
-                      window_scroll_pixel_based_preserve_y, -1,
-                      MOVE_TO_Y | MOVE_TO_X);
+                      goal_y, -1, MOVE_TO_Y | MOVE_TO_X);
           SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
         }
       else
@@ -5197,6 +5210,7 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, bool noerror)
       w->force_start = true;
 
       if (!NILP (Vscroll_preserve_screen_position)
+          && this_scroll_margin == 0
           && (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
         {
           SET_PT_BOTH (pos, pos_byte);
@@ -5222,8 +5236,16 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, bool noerror)
                          marker_byte_position (opoint_marker));
           else if (!NILP (Vscroll_preserve_screen_position))
             {
+              int nlines = window_scroll_preserve_vpos;
+
               SET_PT_BOTH (pos, pos_byte);
-              Fvertical_motion (original_pos, window, Qnil);
+              if (window_scroll_preserve_vpos < this_scroll_margin)
+                nlines = this_scroll_margin;
+              else if (window_scroll_preserve_vpos
+                       >= w->total_lines - this_scroll_margin)
+                nlines = w->total_lines - this_scroll_margin - 1;
+              Fvertical_motion (Fcons (make_number (window_scroll_preserve_hpos),
+                                       make_number (nlines)), window, Qnil);
             }
           else
             SET_PT (top_margin);
@@ -5249,8 +5271,16 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, bool noerror)
             {
               if (!NILP (Vscroll_preserve_screen_position))
                 {
+                  int nlines = window_scroll_preserve_vpos;
+
                   SET_PT_BOTH (pos, pos_byte);
-                  Fvertical_motion (original_pos, window, Qnil);
+                  if (window_scroll_preserve_vpos < this_scroll_margin)
+                    nlines = this_scroll_margin;
+                  else if (window_scroll_preserve_vpos
+                           >= ht - this_scroll_margin)
+                    nlines = ht - this_scroll_margin - 1;
+                  Fvertical_motion (Fcons (make_number (window_scroll_preserve_hpos),
+                                           make_number (nlines)), window, Qnil);
                 }
               else
                 Fvertical_motion (make_number (-1), window, Qnil);