Ticket #2: ,external-format-guessing.patch

cl-irc.asd

@@ -16 +16 @@
     :version "0.5.2"
     :licence "MIT"
     :description "Common Lisp interface to the IRC protocol"
-    :depends-on (:split-sequence :trivial-sockets)
+    :depends-on (:split-sequence :trivial-sockets :flexi-streams)
     :properties ((#:author-email . "cl-irc-devel@common-lisp.net")
                  (#:date . "$Date: 2006/01/24 22:10:58 $")
                  ((#:albert #:output-dir) . "doc/api-doc/")

command.lisp

@@ -250 +250 @@
                      (logging-stream t))
   "Connect to server and return a connection object."
   (let* ((stream (socket-connect server port))
+         (input-stream (flexi-streams:make-flexi-stream stream :element-type 'character :external-format '(:latin-1 :eol-style :crlf)))
          (connection (make-connection :connection-type connection-type
                                       :network-stream stream
+                                      :input-stream input-stream
                                       :client-stream logging-stream
                                       :server-name server))
          (user (make-user connection

protocol.lisp

@@ -117 +117 @@
    (network-stream
     :initarg :network-stream
     :accessor network-stream
-    :documentation "Stream used to talk to the IRC server.")
+    :documentation "Stream used to talk binary to the IRC server.")
+   (input-stream
+    :initarg :input-stream
+    :accessor input-stream
+    :documentation "Stream used to receive messages from the IRC server.")
    (server-capabilities
     :initform *default-isupport-values*
     :accessor server-capabilities
@@ -183 +187 @@
 (defgeneric re-apply-case-mapping (connection))
 
 (defun make-connection (&key (connection-type 'connection)
-                             (user nil)
-                             (server-name "")
-                             (network-stream nil)
-                             (client-stream t)
-                             (hooks nil))
+                        (user nil)
+                        (server-name "")
+                        (network-stream nil)
+                        (output-stream nil)
+                        (input-stream nil)
+                        (client-stream t)
+                        (hooks nil))
   (let ((connection (make-instance connection-type
-                                   :user user
-                                   :server-name server-name
-                                   :network-stream network-stream
-                                   :client-stream client-stream)))
+                       :user user
+                       :server-name server-name
+                       :network-stream network-stream
+                       :input-stream input-stream
+                       :client-stream client-stream)))
     (dolist (hook hooks)
       (add-hook connection (car hook) (cadr hook)))
     connection))
@@ -292 +299 @@
 (defun read-message-loop (connection)
   (loop while (read-message connection)))
 
+(defun try-decode-line (line external-formats)
+  (loop for external-format in external-formats
+        for decoded = nil
+        for error = nil
+        do (multiple-value-setq (decoded error)
+               (handler-case
+                   (flexi-streams:with-input-from-sequence (in line)
+                     (let ((flexi (flexi-streams:make-flexi-stream in :external-format external-format)))
+                       (read-line flexi)))
+                 (flexi-streams:flexi-stream-encoding-error ()
+                   nil)))
+        if decoded
+          do (return decoded)))
+
 (defmethod read-irc-message ((connection connection))
   "Read and parse an IRC-message from the `connection'."
   (handler-case
-    (let ((message (create-irc-message
-                    (read-line (network-stream connection) t))))
-      (setf (connection message) connection)
-      message)
+      (let* ((line (read-line (input-stream connection) t))
+             (message (create-irc-message
+                       (concatenate 'string
+                                    (try-decode-line (map 'vector #'char-code line)
+                                                     *default-incoming-external-formats*)
+                                    '(#\Return)))))
+        (setf (connection message) connection)
+        message)
     (end-of-file ())))
        ;; satisfy read-message-loop assumption of nil when no more messages
 
@@ -306 +331 @@
                              &rest arguments)
   "Turn the arguments into a valid IRC message and send it to the
 server, via the `connection'."
-  (let ((raw-message (apply #'make-irc-message command arguments)))
-    (write-sequence raw-message (network-stream connection))
-    (force-output (network-stream connection))
+  (let ((raw-message (apply #'make-irc-message command arguments))
+        (output (flexi-streams:make-flexi-stream (network-stream connection) :element-type 'character
+                                                 :external-format '(:latin-1 :eol-style :crlf))))
+    (write-sequence raw-message output)
+    (force-output output)
     raw-message))
 
 (defmethod get-hooks ((connection connection) (class symbol))
@@ -370 +397 @@
 ;;
 ;; DCC Connection
 ;;
-
+;;; big TODO: flexi-streams
 (defclass dcc-connection ()
   ((user
     :initarg :user

utility.lisp

@@ -54 +54 @@
 parameters."
   (let ((*print-circle* nil))
     (format nil
-            "~A~{ ~A~}~@[ :~A~]~A~A"
-            command (butlast arguments) (car (last arguments))
-            #\Return #\Linefeed)))
+            "~A~{ ~A~}~@[ :~A~]~%"
+            command (butlast arguments) (car (last arguments)))))
 
 (defun make-ctcp-message (string)
   "Return a valid IRC CTCP message, as a string, composed by
@@ -104 +103 @@
 
 (defun socket-connect (server port)
   "Create a socket connected to `server':`port' and return stream for it."
-  (trivial-sockets:open-stream server port))
+  (trivial-sockets:open-stream server port :element-type '(unsigned-byte 8)))
 
 
 (defun cut-between (string start-char end-chars &key (start 0) (cut-extra t))
-  "If `start-char' is not nil, cut string between `start-char' and any
-of the `end-chars', from `start'.  If `start-char' is nil, cut from
-`start' until any of the `end-chars'.
+  "If `start-char' is not nil, cut string between `start-char'
+and any of the `end-chars', from `start'.  If `start-char' is
+nil, cut from `start' until any of the `end-chars'.
 
 If `cut-extra' is t, we will cut from start + 1 instead of just
 `start'.

variable.lisp

@@ -41 +41 @@
     ("PREFIX" ,*default-isupport-PREFIX*)
     ("TARGMAX")))
 
+(defparameter *default-outgoing-external-format* '(:latin-1 :eol-style :lf)
+  "The external-format we use to encode outgoing messages. This
+  should be an external format spec that flexi-streams accepts,
+  with :eol-style :lf.")
+
+(defparameter *default-incoming-external-formats* '((:utf-8 :eol-style :lf)
+                                                    (:latin-1 :eol-style :lf))
+  "The external-formats we use to decode incoming messages. This
+  should be a list of external format spec that flexi-streams accepts,
+  with :eol-style :lf.
+
+The external formats are tried in order, until one decodes the
+message without encoding errors. Note that the last external
+format should be a single-byte one like latin-1.")
 
 (defvar *dcc-connections* nil)