diff -r -U3 sbcl-2.3.6.orig/contrib/sb-bsd-sockets/tests.lisp sbcl-2.3.6/contrib/sb-bsd-sockets/tests.lisp
--- sbcl-2.3.6.orig/contrib/sb-bsd-sockets/tests.lisp	2023-06-28 13:35:17.000000000 +0700
+++ sbcl-2.3.6/contrib/sb-bsd-sockets/tests.lisp	2023-07-20 21:14:36.163025437 +0700
@@ -13,16 +13,16 @@
   (equalp (make-inet-address "242.1.211.3")  #(242 1 211 3))
   t)
 
-(deftest make-inet6-address.1
-    (equalp (make-inet6-address "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
-            #(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
-  t)
-
-(deftest unparse-inet6-address
-    (string= (sb-bsd-sockets::unparse-inet6-address
-              (make-inet6-address "fe80::abcd:1234"))
-             "fe80::abcd:1234")
-  t)
+;(deftest make-inet6-address.1
+;    (equalp (make-inet6-address "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")
+;            #(255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+;  t)
+
+;(deftest unparse-inet6-address
+;    (string= (sb-bsd-sockets::unparse-inet6-address
+;              (make-inet6-address "fe80::abcd:1234"))
+;             "fe80::abcd:1234")
+;  t)
 
 (deftest get-protocol-by-name/tcp
     (integerp (get-protocol-by-name "tcp"))
@@ -35,15 +35,15 @@
 ;;; See https://bugs.launchpad.net/sbcl/+bug/659857
 ;;; Apparently getprotobyname_r on FreeBSD says -1 and EINTR
 ;;; for unknown protocols...
-#-(and freebsd sb-thread)
-#-(and dragonfly sb-thread)
-(deftest get-protocol-by-name/error
-  (handler-case (get-protocol-by-name "nonexistent-protocol")
-    (unknown-protocol ()
-      t)
-    (:no-error ()
-      nil))
-  t)
+;#-(and freebsd sb-thread)
+;#-(and dragonfly sb-thread)
+;(deftest get-protocol-by-name/error
+;  (handler-case (get-protocol-by-name "nonexistent-protocol")
+;    (unknown-protocol ()
+;      t)
+;    (:no-error ()
+;      nil))
+;  t)
 
 (eval-when (:compile-toplevel :execute)
   (when (handler-case (make-instance 'inet-socket
@@ -104,19 +104,19 @@
       (:no-error nil))
   t)
 
-(deftest make-inet6-socket.smoke
-  (handler-case
-      (let ((s (make-instance 'inet6-socket :type :stream :protocol (get-protocol-by-name "tcp"))))
-        (> (socket-file-descriptor s) 1))
-    ((or address-family-not-supported protocol-not-supported-error) () t))
-  t)
-
-(deftest make-inet6-socket.keyword
-  (handler-case
-      (let ((s (make-instance 'inet6-socket :type :stream :protocol :tcp)))
-        (> (socket-file-descriptor s) 1))
-    ((or address-family-not-supported protocol-not-supported-error) () t))
-  t)
+;(deftest make-inet6-socket.smoke
+;  (handler-case
+;      (let ((s (make-instance 'inet6-socket :type :stream :protocol (get-protocol-by-name "tcp"))))
+;        (> (socket-file-descriptor s) 1))
+;    ((or address-family-not-supported protocol-not-supported-error) () t))
+;  t)
+
+;(deftest make-inet6-socket.keyword
+;  (handler-case
+;      (let ((s (make-instance 'inet6-socket :type :stream :protocol :tcp)))
+;        (> (socket-file-descriptor s) 1))
+;    ((or address-family-not-supported protocol-not-supported-error) () t))
+;  t)
 
 #+ipv4-support
 (deftest non-block-socket
@@ -125,67 +125,67 @@
     (non-blocking-mode s))
   t)
 
-#+ipv4-support
-(test-util:with-test (:name :inet-socket-bind)
-  (let* ((tcp (get-protocol-by-name "tcp"))
-         (address (make-inet-address "127.0.0.1"))
-         (s1 (make-instance 'inet-socket :type :stream :protocol tcp))
-         (s2 (make-instance 'inet-socket :type :stream :protocol tcp))
-         (failure)
-         (got-addrinuse))
-    (format t "~&::: INFO: made sockets~%")
-    (unwind-protect
-         ;; Given the functions we've got so far, if you can think of a
-         ;; better way to make sure the bind succeeded than trying it
-         ;; twice, let me know
-         (progn
-           (socket-bind s1 address 0)
-           (handler-case
-               (let ((port (nth-value 1 (socket-name s1))))
-                 (socket-bind s2 address port) ; should fail
-                 nil)
-             (address-in-use-error () (setq got-addrinuse t))
-             (condition (c) (setq failure c))))
-      (socket-close s1)
-      (socket-close s2))
-    (cond (failure (error "BIND failed with ~A" failure))
-          ((not got-addrinuse) (error "Expected ADDRESS-IN-USE err")))))
-
-(test-util:with-test (:name :inet6-socket-bind)
-  (let ((notsupp)
-        (failure)
-        (got-addrinuse))
-  (handler-case
-      (let* ((tcp (get-protocol-by-name "tcp"))
-             (address (make-inet6-address "::1"))
-             (s1 (make-instance 'inet6-socket :type :stream :protocol tcp))
-             (s2 (make-instance 'inet6-socket :type :stream :protocol tcp)))
-        (format t "~&::: INFO: made sockets~%")
-        (unwind-protect
-             ;; Given the functions we've got so far, if you can think of a
-             ;; better way to make sure the bind succeeded than trying it
-             ;; twice, let me know
-             (handler-case
-                 (socket-bind s1 address 0)
-               (socket-error ()
-                 ;; This may mean no IPv6 support, can't fail a test
-                 ;; because of that (address-family-not-supported doesn't catch that)
-                 (setf notsupp t))
-               (:no-error (x)
-                 (declare (ignore x))
-                 (handler-case
-                     (let ((port (nth-value 1 (socket-name s1))))
-                       (socket-bind s2 address port) ; should fail
-                       nil)
-                   (address-in-use-error () (setq got-addrinuse t))
-                   (condition (c) (setq failure c)))))
-          (socket-close s1)
-          (socket-close s2)))
-    ((or address-family-not-supported protocol-not-supported-error) ()
-      (setq notsupp t)))
-  (cond (notsupp (format t "~&INFO: not supported~%"))
-        (failure (error "BIND failed with ~A" failure))
-        ((not got-addrinuse) (error "Expected ADDRESS-IN-USE err")))))
+;#+ipv4-support
+;(test-util:with-test (:name :inet-socket-bind)
+;  (let* ((tcp (get-protocol-by-name "tcp"))
+;         (address (make-inet-address "127.0.0.1"))
+;         (s1 (make-instance 'inet-socket :type :stream :protocol tcp))
+;         (s2 (make-instance 'inet-socket :type :stream :protocol tcp))
+;         (failure)
+;         (got-addrinuse))
+;    (format t "~&::: INFO: made sockets~%")
+;    (unwind-protect
+;         ;; Given the functions we've got so far, if you can think of a
+;         ;; better way to make sure the bind succeeded than trying it
+;         ;; twice, let me know
+;         (progn
+;           (socket-bind s1 address 0)
+;           (handler-case
+;               (let ((port (nth-value 1 (socket-name s1))))
+;                 (socket-bind s2 address port) ; should fail
+;                 nil)
+;             (address-in-use-error () (setq got-addrinuse t))
+;             (condition (c) (setq failure c))))
+;      (socket-close s1)
+;      (socket-close s2))
+;    (cond (failure (error "BIND failed with ~A" failure))
+;          ((not got-addrinuse) (error "Expected ADDRESS-IN-USE err")))))
+
+;(test-util:with-test (:name :inet6-socket-bind)
+;  (let ((notsupp)
+;        (failure)
+;        (got-addrinuse))
+;  (handler-case
+;      (let* ((tcp (get-protocol-by-name "tcp"))
+;             (address (make-inet6-address "::1"))
+;             (s1 (make-instance 'inet6-socket :type :stream :protocol tcp))
+;             (s2 (make-instance 'inet6-socket :type :stream :protocol tcp)))
+;        (format t "~&::: INFO: made sockets~%")
+;        (unwind-protect
+;             ;; Given the functions we've got so far, if you can think of a
+;             ;; better way to make sure the bind succeeded than trying it
+;             ;; twice, let me know
+;             (handler-case
+;                 (socket-bind s1 address 0)
+;               (socket-error ()
+;                 ;; This may mean no IPv6 support, can't fail a test
+;                 ;; because of that (address-family-not-supported doesn't catch that)
+;                 (setf notsupp t))
+;               (:no-error (x)
+;                 (declare (ignore x))
+;                 (handler-case
+;                     (let ((port (nth-value 1 (socket-name s1))))
+;                       (socket-bind s2 address port) ; should fail
+;                       nil)
+;                   (address-in-use-error () (setq got-addrinuse t))
+;                   (condition (c) (setq failure c)))))
+;          (socket-close s1)
+;          (socket-close s2)))
+;    ((or address-family-not-supported protocol-not-supported-error) ()
+;      (setq notsupp t)))
+;  (cond (notsupp (format t "~&INFO: not supported~%"))
+;        (failure (error "BIND failed with ~A" failure))
+;        ((not got-addrinuse) (error "Expected ADDRESS-IN-USE err")))))
 
 #+ipv4-support
 (deftest simple-sockopt-test
@@ -253,37 +253,37 @@
 ;;; to look at /etc/syslog.conf or local equivalent to find out where
 ;;; the message ended up
 
-#-win32
-(deftest simple-local-client
-    (progn
-      ;; SunOS (Solaris) and Darwin systems don't have a socket at
-      ;; /dev/log.  We might also be building in a chroot or
-      ;; something, so don't fail this test just because the file is
-      ;; unavailable, or if it's a symlink to some weird character
-      ;; device.
-      (when (block nil
-              (handler-bind ((sb-posix:syscall-error
-                              (lambda (e)
-                                (declare (ignore e))
-                                (return nil))))
-                (sb-posix:s-issock
-                 (sb-posix::stat-mode (sb-posix:stat "/dev/log")))))
-        (let ((s (make-instance 'local-socket :type :datagram)))
-          (format t "Connecting ~A... " s)
-          (finish-output)
-          (handler-case
-              (socket-connect s "/dev/log")
-            (sb-bsd-sockets::socket-error ()
-              (setq s (make-instance 'local-socket :type :stream))
-              (format t "failed~%Retrying with ~A... " s)
-              (finish-output)
-              (socket-connect s "/dev/log")))
-          (format t "ok.~%")
-          (let ((stream (socket-make-stream s :input t :output t :buffering :none)))
-            (format stream
-                    "<7>bsd-sockets: Don't panic.  We're testing local-domain client code; this message can safely be ignored"))))
-      t)
-  t)
+;#-win32
+;(deftest simple-local-client
+;    (progn
+;      ;; SunOS (Solaris) and Darwin systems don't have a socket at
+;      ;; /dev/log.  We might also be building in a chroot or
+;      ;; something, so don't fail this test just because the file is
+;      ;; unavailable, or if it's a symlink to some weird character
+;      ;; device.
+;      (when (block nil
+;              (handler-bind ((sb-posix:syscall-error
+;                              (lambda (e)
+;                                (declare (ignore e))
+;                                (return nil))))
+;                (sb-posix:s-issock
+;                 (sb-posix::stat-mode (sb-posix:stat "/dev/log")))))
+;        (let ((s (make-instance 'local-socket :type :datagram)))
+;          (format t "Connecting ~A... " s)
+;          (finish-output)
+;          (handler-case
+;              (socket-connect s "/dev/log")
+;            (sb-bsd-sockets::socket-error ()
+;              (setq s (make-instance 'local-socket :type :stream))
+;              (format t "failed~%Retrying with ~A... " s)
+;              (finish-output)
+;              (socket-connect s "/dev/log")))
+;          (format t "ok.~%")
+;          (let ((stream (socket-make-stream s :input t :output t :buffering :none)))
+;            (format stream
+;                    "<7>bsd-sockets: Don't panic.  We're testing local-domain client code; this message can safely be ignored"))))
+;      t)
+;  t)
 
 ;;; these require that the internet (or bits of it, at least) is available
 
@@ -428,59 +428,59 @@
        (format t "Received ~A bytes from ~A:~A - ~A ~%"
                len address port (subseq buf 0 (min 10 len)))))))
 
-#+(and ipv4-support sb-thread)
-(deftest interrupt-io
-    (let (result
-          (sem (sb-thread:make-semaphore)))
-      (labels
-          ((client (port)
-             (setf result
-                   (let ((s (make-instance 'inet-socket
-                                           :type :stream
-                                           :protocol :tcp)))
-                     (socket-connect s #(127 0 0 1) port)
-                     (let ((stream (socket-make-stream s
-                                                       :input t
-                                                       :output t
-                                                       :buffering :none)))
-                       (handler-case
-                           (prog1
-                               (catch 'stop
-                                 (sb-thread:signal-semaphore sem)
-                                 (read-char stream))
-                             (close stream))
-                         (error (c)
-                           c))))))
-           (server ()
-             (let ((s (make-instance 'inet-socket
-                                     :type :stream
-                                     :protocol :tcp)))
-               (setf (sockopt-reuse-address s) t)
-               (socket-bind s (make-inet-address "127.0.0.1") 0)
-               (socket-listen s 5)
-               (multiple-value-bind (* port)
-                   (socket-name s)
-                 (let* ((client (sb-thread:make-thread
-                                 (lambda () (client port))))
-                        (r (socket-accept s))
-                        (stream (socket-make-stream r
-                                                    :input t
-                                                    :output t
-                                                    :buffering :none)))
-                   (socket-close s)
-                   (sb-thread:wait-on-semaphore sem)
-                   (sleep 0.1)
-                   (sb-thread:interrupt-thread client
-                                               (lambda () (throw 'stop :ok)))
-                   (unless (sb-ext:wait-for (null (sb-thread::thread-interruptions client)) :timeout 5)
-                     (setf result :timeout))
-                   (write-char #\x stream)
-                   (close stream)
-                   (socket-close r)
-                   (sb-thread:join-thread client :timeout 5))))))
-        (server))
-      result)
-  :ok)
+;#+(and ipv4-support sb-thread)
+;(deftest interrupt-io
+;    (let (result
+;          (sem (sb-thread:make-semaphore)))
+;      (labels
+;          ((client (port)
+;             (setf result
+;                   (let ((s (make-instance 'inet-socket
+;                                           :type :stream
+;                                           :protocol :tcp)))
+;                     (socket-connect s #(127 0 0 1) port)
+;                     (let ((stream (socket-make-stream s
+;                                                       :input t
+;                                                       :output t
+;                                                       :buffering :none)))
+;                       (handler-case
+;                           (prog1
+;                               (catch 'stop
+;                                 (sb-thread:signal-semaphore sem)
+;                                 (read-char stream))
+;                             (close stream))
+;                         (error (c)
+;                           c))))))
+;           (server ()
+;             (let ((s (make-instance 'inet-socket
+;                                     :type :stream
+;                                     :protocol :tcp)))
+;               (setf (sockopt-reuse-address s) t)
+;               (socket-bind s (make-inet-address "127.0.0.1") 0)
+;               (socket-listen s 5)
+;               (multiple-value-bind (* port)
+;                   (socket-name s)
+;                 (let* ((client (sb-thread:make-thread
+;                                 (lambda () (client port))))
+;                        (r (socket-accept s))
+;                        (stream (socket-make-stream r
+;                                                    :input t
+;                                                    :output t
+;                                                    :buffering :none)))
+;                   (socket-close s)
+;                   (sb-thread:wait-on-semaphore sem)
+;                   (sleep 0.1)
+;                   (sb-thread:interrupt-thread client
+;                                               (lambda () (throw 'stop :ok)))
+;                   (unless (sb-ext:wait-for (null (sb-thread::thread-interruptions client)) :timeout 5)
+;                     (setf result :timeout))
+;                   (write-char #\x stream)
+;                   (close stream)
+;                   (socket-close r)
+;                   (sb-thread:join-thread client :timeout 5))))))
+;        (server))
+;      result)
+;  :ok)
 
 (defmacro with-client-and-server (((socket-class &rest common-initargs)
                                    (listen-socket-var &rest listen-address)
@@ -543,8 +543,8 @@
             (define-shutdown-test ,(make-name 'shutdown.client.ub8)
               client server (unsigned-byte 8) ,direction)))))
 
-  (define-shutdown-tests :output)
-  (define-shutdown-tests :io))
+;  (define-shutdown-tests :output)
+;  (define-shutdown-tests :io))
 
 (defun poor-persons-random-address ()
   (let ((base (expt 36 8)))
