anchor.diff:  
   (defun (setf getf-uuid-session) (val uuid var)
     (setf (getf-session (uuid-session uuid) var) val))
  +
  +(defun delete-session (session)
  +  (log-message :debug "Going to delete session ~a" (car session))
  +  (setq *sessions* (delete session *sessions* :test #'eq))
  +  (setq *websocket-handlers* (delete (getf-session session :dispatcher) *websocket-handlers* :test #'eq)))
   
   (defun send-disconnect ()
     (websocket-send-message "0::"))
  
positive.code:              (setf (getf-session *session* :receive-timestamp) (get-universal-time)))))
          (log-message :error "Message is malfomed"))))
  
  (defun handle-handshake (scanner message-handler)
    (let* ((session-id (uuid:make-v4-uuid))
           (timeout *close-timeout*)
           (heartbeat (timeout-heartbeat timeout))
           (session (list session-id :heartbeat-timeout heartbeat :close-timeout timeout :message-id 0)))
      (push session *sessions*)
      (push #'(lambda (request) ; dispatcher
                (and (scan scanner (script-name request))
                     (uuid-equal-p (uuid:make-uuid-from-string (cadr (path-info* request)))
                                   session-id)
                     #'(lambda (stream mutex) ; handshake handler
                         (send-connect)
                         (setf (getf (cdr session) :stream) stream
                               (getf (cdr session) :mutex) mutex)
                         #'(lambda (message) ; message handler
                             (let ((*session* session))
                               (handle-message message message-handler))))))
            *websocket-handlers*)
      (format nil "~a:~d:~d:~{~a~^,~}" session-id heartbeat timeout (list "websocket"))))
  
  (defun handle-disconnect (reply session-id)
    (let* ((uuid (make-uuid-from-string session-id))
  
negative.code:          (uuid:uuid-to-byte-array uuid-1)
           (uuid:uuid-to-byte-array uuid-2)))
  
  (defun uuid-session (uuid)
    (assoc uuid *sessions* :test #'uuid-equal-p))
  
  