How to use Clozure CL on IPv6 only network?

Question

I've tried to replace SBCL with Clozure CL when working in IPv6 only network, but encountered an error like that:

MIGRATIONS> (ignore-errors (ccl:make-socket :remote-host "ya.ru" :remote-port 443))
NIL
#<CCL:NO-APPLICABLE-METHOD-EXISTS #x302005215E5D>
MIGRATIONS> (ignore-errors (ccl:make-socket :remote-host "ya.ru" :remote-port 443 :address-family :internet))
NIL
#<CCL:NO-APPLICABLE-METHOD-EXISTS #x3020052549AD>
MIGRATIONS> (ignore-errors (ccl:make-socket :remote-host "ya.ru" :remote-port 443 :address-family :internet6))
#<BASIC-TCP-STREAM ISO-8859-1 (SOCKET/16) #x3020051D4A9D>

The problem is that many libraries when using CCL:MAKE-TCP-SOCKET don't specify address-family or specify an :internet.

Is there is a way to patch ccl:make-socket at runtime to override this setting?

Answer 1

Advise a function

Several implementations of Common Lisp allow advising (-> patching) of normal functions. Advising is a non-standard feature and different implementations provide it in slightly different ways. A related mechanism is standardized for CLOS generic functions with :before, :after and :around methods.

The purpose is to add one or more patches to a function, after it has been defined and without altering the original source code.

Typically this requires that the function call to this function is not inlined.

The macro ADVISE in Clozure Common Lisp

Patching functions in Clozure CL can be done with the macro ADVISE. See the documentation for advising.

Let's say we have a function FOOBAR:

? (defun foobar (a b &key c (d :foobar)) (list a b c d))
FOOBAR

FOOBAR gets called inside TEST:

? (defun test (a) (foobar a 20 :c 30))
TEST

? (test 10)
(10 20 30 :FOOBAR)

We now want to patch FOOBAR such that named arg :D gets called with a different value.

We change the arglist to insert the new named argument after the two required args:

? (advise foobar (let ((arglist (list* (first arglist)
                                       (second arglist)
                                       :d :ipv6
                                       (cddr arglist))))
                   (:do-it))   ; calling the original function
          :when :around     ; advise around it
          :name :ipv6)      ; the name of this advise
#<Compiled-function (CCL::ADVISED 'FOOBAR) (Non-Global)  #x3020010D1CCF>

Now we can call our TEST function and it will call the advised function FOOBAR.

? (test 10)
(10 20 30 :IPV6)

Advise for CCL:MAKE-SOCKET

You could write a similar advise for CCL:MAKE-SOCKET.

Untested:

(advise ccl:make-socket (let ((arglist (list* :address-family
                                              :internet6
                                              arglist)))
                          (:do-it))
        :when :around
        :name :internet6)

Answer 2

This can be done!

First make a copy of the original make-socket

(IN-PACKAGE :ccl)
(DEFPARAMETER original-make-socket #'make-socket)

Then redefine make-socket. Note: You will have to provide the full spec for all keyword parameters. As it is, I've used only the ones from your question for demonstration.

(defun make-socket (&key (remote-host "defau.lt") 
                         (remote-port 443) 
                         (address-family :internet6))
  (declare (ignore address-family))
  (format t "Calling new make-socket with address-family as internet6!")
  (funcall original-make-socket 
           :remote-host remote-host 
           :remote-port remote-port 
           :address-family :internet6))

This will signal a continuable error.

Type :go at the repl to continue. This will successfully patch make-socket.

Now any calls to make-socket will be to the new definition. Try:

(IN-PACKAGE :cl-user)
(ccl:make-socket :remote-host "ya.ru" :remote-port 443 :address-family :IRRELEVANT)

---

Another way to do it, would be to override the global variable *warn-if-redefine-kernel* before redefining make-socket.

(setf *warn-if-redefine-kernel* nil)

This will avoid the continuable error signal, and straight patch the kernel function.