Changes to open-protocol-stream, preparing for merging it with open-network-stream.

* lisp/gnus/proto-stream.el: Changes preparatory to merging open-protocol-stream
with open-network-stream.
(proto-stream-always-use-starttls): Option removed.
(open-protocol-stream): Return a process object by default.  Provide a
new parameter :return-list specifying a list-type return value, which
now has the form (PROP . PLIST) instead of a fixed-length list.  Change
:type `network' to `try-starttls', and `network-only' to `default'.
Make `default' the default, for compatibility with open-network-stream.
Handle the no-parameter case exactly as open-network-stream, with no
additional stream processing.  Search plists using plist-get.
Explicitly add :end-of-commend parameter if it is missing.
(proto-stream-open-default): Renamed from
proto-stream-open-network-only.  Return 'default as the type.
(proto-stream-open-starttls): Rename from proto-stream-open-network.
Use plist-get.  Don't return `tls' as the type if STARTTLS negotiation
failed.  Always return a list with a (possibly dead) process as the
first element, for compatibility with open-network-stream.
(proto-stream-open-tls): Use plist-get.  Always return a list.
(proto-stream-open-shell): Return `default' as connection type.
(proto-stream-capability-open): Use plist-get.
(proto-stream-eoc): Function deleted.

* lisp/gnus/nnimap.el (nnimap-stream, nnimap-open-connection)
(nnimap-open-connection-1): Handle renaming of :type parameter for
open-protocol-stream.
(nnimap-open-connection-1): Pass a :return-list parameter
open-protocol-stream to obtain a list return value.  Parse this list
using plist-get.

* lisp/gnus/nntp.el (nntp-open-connection): Handle renaming of :type parameter
for open-protocol-stream.  Accept open-protocol-stream return value
that is a subprocess object instead of a list.  Handle the case of a
dead returned process.

4 files changed, 232 insertions, 199 deletions

diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index ddc946383b6..f257ff51f3d 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,39 @@
+2011-03-26  Chong Yidong  <cyd@stupidchicken.com>
+
+	* proto-stream.el: Changes preparatory to merging open-protocol-stream
+	with open-network-stream.
+	(proto-stream-always-use-starttls): Option removed.
+	(open-protocol-stream): Return a process object by default.  Provide a
+	new parameter :return-list specifying a list-type return value, which
+	now has the form (PROP . PLIST) instead of a fixed-length list.  Change
+	:type `network' to `try-starttls', and `network-only' to `default'.
+	Make `default' the default, for compatibility with open-network-stream.
+	Handle the no-parameter case exactly as open-network-stream, with no
+	additional stream processing.  Search plists using plist-get.
+	Explicitly add :end-of-commend parameter if it is missing.
+	(proto-stream-open-default): Renamed from
+	proto-stream-open-network-only.  Return 'default as the type.
+	(proto-stream-open-starttls): Rename from proto-stream-open-network.
+	Use plist-get.  Don't return `tls' as the type if STARTTLS negotiation
+	failed.  Always return a list with a (possibly dead) process as the
+	first element, for compatibility with open-network-stream.
+	(proto-stream-open-tls): Use plist-get.  Always return a list.
+	(proto-stream-open-shell): Return `default' as connection type.
+	(proto-stream-capability-open): Use plist-get.
+	(proto-stream-eoc): Function deleted.
+
+	* nnimap.el (nnimap-stream, nnimap-open-connection)
+	(nnimap-open-connection-1): Handle renaming of :type parameter for
+	open-protocol-stream.
+	(nnimap-open-connection-1): Pass a :return-list parameter
+	open-protocol-stream to obtain a list return value.  Parse this list
+	using plist-get.
+
+	* nntp.el (nntp-open-connection): Handle renaming of :type parameter
+	for open-protocol-stream.  Accept open-protocol-stream return value
+	that is a subprocess object instead of a list.  Handle the case of a
+	dead returned process.
+
 2011-03-25  Teodor Zlatanov  <tzz@lifelogs.com>
 
 	* mm-util.el (mm-handle-filename): Move to mm-decode.el (bug#8330).
diff --git a/lisp/gnus/nnimap.el b/lisp/gnus/nnimap.el
index bcbe7b678d5..15d7f463d41 100644
--- a/lisp/gnus/nnimap.el
+++ b/lisp/gnus/nnimap.el
@@ -62,9 +62,9 @@ it will default to `imap'.")
 
 (defvoo nnimap-stream 'undecided
   "How nnimap will talk to the IMAP server.
-Values are `ssl', `network', `network-only, `starttls' or
+Values are `ssl', `default', `try-starttls', `starttls' or
 `shell'.  The default is to try `ssl' first, and then
-`network'.")
+`try-starttls'.")
 
 (defvoo nnimap-shell-program (if (boundp 'imap-shell-program)
 				 (if (listp imap-shell-program)
@@ -319,7 +319,7 @@ textual parts.")
     (setq nnimap-stream 'ssl))
   (let ((stream
 	 (if (eq nnimap-stream 'undecided)
-	     (loop for type in '(ssl network)
+	     (loop for type in '(ssl try-starttls)
 		   for stream = (let ((nnimap-stream type))
 				  (nnimap-open-connection-1 buffer))
 		   while (eq stream 'no-connect)
@@ -339,9 +339,7 @@ textual parts.")
 	   (port nil)
 	   (ports
 	    (cond
-	     ((or (eq nnimap-stream 'network)
-		  (eq nnimap-stream 'network-only)
-		  (eq nnimap-stream 'starttls))
+	     ((memq nnimap-stream '(try-starttls default starttls))
 	      (nnheader-message 7 "Opening connection to %s..."
 				nnimap-address)
 	      '("imap" "143"))
@@ -355,21 +353,28 @@ textual parts.")
 	      '("imaps" "imap" "993" "143"))
 	     (t
 	      (error "Unknown stream type: %s" nnimap-stream))))
-	   (proto-stream-always-use-starttls t)
            login-result credentials)
       (when nnimap-server-port
 	(push nnimap-server-port ports))
-      (destructuring-bind (stream greeting capabilities stream-type)
-	  (open-protocol-stream
-	   "*nnimap*" (current-buffer) nnimap-address (car ports)
-	   :type nnimap-stream
-	   :shell-command nnimap-shell-program
-	   :capability-command "1 CAPABILITY\r\n"
-	   :success " OK "
-	   :starttls-function
-	   (lambda (capabilities)
-	     (when (gnus-string-match-p "STARTTLS" capabilities)
-	       "1 STARTTLS\r\n")))
+      (let* ((stream-list
+	      (open-protocol-stream
+	       "*nnimap*" (current-buffer) nnimap-address (car ports)
+	       :type nnimap-stream
+	       :return-list t
+	       :shell-command nnimap-shell-program
+	       :capability-command "1 CAPABILITY\r\n"
+	       :success " OK "
+	       :starttls-function
+	       (lambda (capabilities)
+		 (when (gnus-string-match-p "STARTTLS" capabilities)
+		   "1 STARTTLS\r\n"))))
+	     (stream (car stream-list))
+	     (props (cdr stream-list))
+	     (greeting (plist-get props :greeting))
+	     (capabilities (plist-get props :capabilities))
+	     (stream-type (plist-get props :type)))
+	(when (and stream (not (memq (process-status stream) '(open run))))
+	  (setq stream nil))
 	(setf (nnimap-process nnimap-object) stream)
 	(setf (nnimap-stream-type nnimap-object) stream-type)
 	(if (not stream)
diff --git a/lisp/gnus/nntp.el b/lisp/gnus/nntp.el
index 66a6365cb3b..9065027d34f 100644
--- a/lisp/gnus/nntp.el
+++ b/lisp/gnus/nntp.el
@@ -1339,26 +1339,26 @@ password contained in '~/.nntp-authinfo'."
 	  (condition-case err
 	      (let ((coding-system-for-read nntp-coding-system-for-read)
 		    (coding-system-for-write nntp-coding-system-for-write)
-		    (map '((nntp-open-network-stream network)
-			   (network-only network-only)
+		    (map '((nntp-open-network-stream try-starttls)
+			   (network-only default)
 			   (nntp-open-ssl-stream tls)
 			   (nntp-open-tls-stream tls))))
 		(if (assoc nntp-open-connection-function map)
-		    (car (open-protocol-stream
-			  "nntpd" pbuffer nntp-address nntp-port-number
-			  :type (cadr
-				 (assoc nntp-open-connection-function map))
-			  :end-of-command "^\\([2345]\\|[.]\\).*\n"
-			  :capability-command "CAPABILITIES\r\n"
-			  :success "^3"
-			  :starttls-function
-			  (lambda (capabilities)
-			    (if (not (string-match "STARTTLS" capabilities))
-				nil
-			      "STARTTLS\r\n"))))
+		    (open-protocol-stream
+		     "nntpd" pbuffer nntp-address nntp-port-number
+		     :type (or (cadr (assoc nntp-open-connection-function map))
+			       'try-starttls)
+		     :end-of-command "^\\([2345]\\|[.]\\).*\n"
+		     :capability-command "CAPABILITIES\r\n"
+		     :success "^3"
+		     :starttls-function
+		     (lambda (capabilities)
+		       (if (not (string-match "STARTTLS" capabilities))
+			   nil
+			 "STARTTLS\r\n")))
 		  (funcall nntp-open-connection-function pbuffer)))
 	    (error
-	     (nnheader-report 'nntp "%s" err))
+	     (nnheader-report 'nntp ">>> %s" err))
 	    (quit
 	     (message "Quit opening connection to %s" nntp-address)
 	     (nntp-kill-buffer pbuffer)
@@ -1366,6 +1366,9 @@ password contained in '~/.nntp-authinfo'."
 	     nil))))
     (when timer
       (nnheader-cancel-timer timer))
+    (when (and process
+	       (not (memq (process-status process) '(open run))))
+      (setq process nil))
     (unless process
       (nntp-kill-buffer pbuffer))
     (when (and (buffer-name pbuffer)
diff --git a/lisp/gnus/proto-stream.el b/lisp/gnus/proto-stream.el
index fdf2abfea05..5e92cb40264 100644
--- a/lisp/gnus/proto-stream.el
+++ b/lisp/gnus/proto-stream.el
@@ -37,7 +37,7 @@
 
 ;; (open-protocol-stream
 ;;  "*nnimap*" buffer address port
-;;  :type 'network
+;;  :type 'try-starttls
 ;;  :capability-command "1 CAPABILITY\r\n"
 ;;  :success " OK "
 ;;  :starttls-function
@@ -48,171 +48,164 @@
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'cl))
 (require 'tls)
 (require 'starttls)
-(require 'format-spec)
-
-(defcustom proto-stream-always-use-starttls (fboundp 'open-gnutls-stream)
-  "If non-nil, always try to upgrade network connections with STARTTLS."
-  :version "24.1"
-  :type 'boolean
-  :group 'comm)
 
 (declare-function gnutls-negotiate "gnutls"
 		  (proc type &optional priority-string trustfiles keyfiles))
 
 ;;;###autoload
 (defun open-protocol-stream (name buffer host service &rest parameters)
-  "Open a network stream to HOST, upgrading to STARTTLS if possible.
-The first four parameters have the same meaning as in
-`open-network-stream'.  The function returns a list where the
-first element is the stream, the second element is the greeting
-the server replied with after connecting, and the third element
-is a string representing the capabilities of the server (if any).
-
-The PARAMETERS is a keyword list that can have the following
-values:
-
-:type -- either `network', `network-only, `tls', `shell' or
-`starttls'.  If omitted, the default is `network'.  `network'
-will be opportunistically upgraded to STARTTLS if both the server
-and Emacs supports it.  If you don't want STARTTLS upgrades, use
-`network-only'.
-
-:end-of-command -- a regexp saying what the end of a command is.
-This defaults to \"\\n\".
-
-:success -- a regexp saying whether the STARTTLS command was
-successful or not.  For instance, for NNTP this is \"^3\".
-
-:capability-command -- a string representing the command used to
-query server for capabilities.  For instance, for IMAP this is
-\"1 CAPABILITY\\r\\n\".
-
-:starttls-function -- a function that takes one parameter, which
-is the response to the capaibility command.  It should return nil
-if it turns out that the server doesn't support STARTTLS, or the
-command to switch on STARTTLS otherwise.
-
-The return value from this function is a four-element list, where
-the first element is the stream (if connection was successful);
-the second element is the \"greeting\", i. e., the string the
-server sent over on initial contact; the third element is the
-capability string; and the fourth element is either `network' or
-`tls', depending on whether the connection ended up being
-encrypted or not."
-  (let ((type (or (cadr (memq :type parameters)) 'network)))
-    (cond
-     ((eq type 'starttls)
-      (setq type 'network))
-     ((eq type 'ssl)
-      (setq type 'tls)))
-    (let ((open-result
-	   (funcall (intern (format "proto-stream-open-%s" type) obarray)
-		    name buffer host service parameters)))
-      (if (null open-result)
-	  (list nil nil nil type)
-	(let ((stream (car open-result)))
-	  (list (and stream
-		     (memq (process-status stream)
-			   '(open run))
-		     stream)
-		(nth 1 open-result)
-		(nth 2 open-result)
-		(nth 3 open-result)))))))
-
-(defun proto-stream-open-network-only (name buffer host service parameters)
+  "Open a network stream to HOST, possibly with encryption.
+Normally, return a network process object; with a non-nil
+:return-list parameter, return a list instead (see below).
+
+The first four parameters, NAME, BUFFER, HOST, and SERVICE, have
+the same meanings as in `open-network-stream'.  The remaining
+PARAMETERS should be a sequence of keywords and values:
+
+:type specifies the connection type, one of the following:
+  `default'  -- An ordinary network connection.
+  `try-starttls'
+             -- Begin an ordinary network connection, and try
+                upgrading it to an encrypted connection via
+                STARTTLS if both HOST and Emacs support TLS.  If
+                that fails, keep the unencrypted connection.
+  `starttls' -- Begin an ordinary connection, and try upgrading
+                it via STARTTLS.  If that fails for any reason,
+                drop the connection; in this case, the returned
+                process object is a killed process.
+  `tls' or `ssl' -- A TLS connection.
+  `shell'    -- A shell connection.
+
+:return-list specifies this function's return value.
+  If omitted or nil, return a process object.  A non-nil means to
+  return (PROC . PROPS), where PROC is a process object and PROPS
+  is a plist of connection properties, with these keywords:
+   :greeting -- the greeting returned by HOST (a string), or nil.
+   :capabilities -- a string representing HOST's capabilities,
+                    or nil if none could be found.
+   :type -- the actual connection type; either `default' for an
+            unencrypted connection, or `tls'.
+
+:end-of-command specifies a regexp matching the end of a command.
+  If non-nil, it defaults to \"\\n\".
+
+:success specifies a regexp matching a message indicating a
+  successful STARTTLS negotiation.  For instance, the default
+  should be \"^3\" for an NNTP connection.  If this is not
+  supplied, STARTTLS will always fail.
+
+:capability-command specifies a command used to query the HOST
+  for its capabilities.  For instance, for IMAP this should be
+  \"1 CAPABILITY\\r\\n\".
+
+:starttls-function specifies a function for handling STARTTLS.
+  This function should take one parameter, the response to the
+  capability command, and should return the command to switch on
+  STARTTLS if the server supports STARTTLS, and nil otherwise."
+  (let ((type (plist-get parameters :type))
+	(return-list (plist-get parameters :return-list)))
+    (if (and (null return-list) (memq type '(nil default)))
+	;; The simplest case---no encryption, and no need to report
+	;; connection properties.  Like `open-network-stream', this
+	;; doesn't read anything into BUFFER yet.
+	(open-network-stream name buffer host service)
+      ;; For everything else, refer to proto-stream-open-*.
+      (unless (plist-get parameters :end-of-command)
+	(setq parameters
+	      (append '(:end-of-command "\r\n") parameters)))
+      (let* ((connection-function
+	      (cond
+	       ((memq type '(nil default))
+		'proto-stream-open-default)
+	       ((memq type '(try-starttls starttls))
+		'proto-stream-open-starttls)
+	       ((memq type '(tls ssl))
+		'proto-stream-open-tls)
+	       ((eq type 'shell)
+		'proto-stream-open-shell)
+	       (t
+		(error "Invalid connection type %s" type))))
+	     (result (funcall connection-function
+			      name buffer host service parameters)))
+	(if return-list
+	    (list (car result)
+		  :greeting     (nth 1 result)
+		  :capabilities (nth 2 result)
+		  :type         (nth 3 result))
+	  (car result))))))
+
+(defun proto-stream-open-default (name buffer host service parameters)
   (let ((start (with-current-buffer buffer (point)))
 	(stream (open-network-stream name buffer host service)))
     (list stream
-	  (proto-stream-get-response
-	   stream start (proto-stream-eoc parameters))
+	  (proto-stream-get-response stream start
+				     (plist-get parameters :end-of-command))
 	  nil
-	  'network)))
+	  'default)))
 
-(defun proto-stream-open-network (name buffer host service parameters)
+(defun proto-stream-open-starttls (name buffer host service parameters)
   (let* ((start (with-current-buffer buffer (point)))
+	 ;; This should be `starttls' or `try-starttls'.
+	 (type               (plist-get parameters :type))
+	 (starttls-function  (plist-get parameters :starttls-function))
+	 (success-string     (plist-get parameters :success))
+	 (capability-command (plist-get parameters :capability-command))
+	 (eoc                (plist-get parameters :end-of-command))
+	 ;; Return (STREAM GREETING CAPABILITIES RESULTING-TYPE)
 	 (stream (open-network-stream name buffer host service))
-	 (capability-command (cadr (memq :capability-command parameters)))
-	 (eoc (proto-stream-eoc parameters))
-	 (type (cadr (memq :type parameters)))
 	 (greeting (proto-stream-get-response stream start eoc))
-	 success)
-    (if (not capability-command)
-	(list stream greeting nil 'network)
-      (let* ((capabilities
-	      (proto-stream-command stream capability-command eoc))
-	     (starttls-command
-	      (funcall (cadr (memq :starttls-function parameters))
-		       capabilities)))
-	(cond
-	  ;; If this server doesn't support STARTTLS, but we have
-	  ;; requested it explicitly, then close the connection and
-	  ;; return nil.
-	 ((or (not starttls-command)
-	      (and (not (eq type 'starttls))
-		   (not proto-stream-always-use-starttls)))
-	  (if (eq type 'starttls)
-	      (progn
-		(delete-process stream)
-		nil)
-	    ;; Otherwise, just return this plain network connection.
-	    (list stream greeting capabilities 'network)))
-	 ;; We have some kind of STARTTLS support, so we try to
-	 ;; upgrade the connection opportunistically.
-	 ((or (fboundp 'open-gnutls-stream)
-	      (executable-find "gnutls-cli"))
-	  (unless (fboundp 'open-gnutls-stream)
-	    (delete-process stream)
-	    (setq start (with-current-buffer buffer (point-max)))
-	    (let* ((starttls-use-gnutls t)
-		   (starttls-extra-arguments
-		    (if (not (eq type 'starttls))
-			;; When doing opportunistic TLS upgrades we
-			;; don't really care about the identity of the
-			;; peer.
-			(cons "--insecure" starttls-extra-arguments)
-		      starttls-extra-arguments)))
-	      (setq stream (starttls-open-stream name buffer host service)))
-	    (proto-stream-get-response stream start eoc))
-	  (if (not
-	       (string-match
-		(cadr (memq :success parameters))
-		(proto-stream-command stream starttls-command eoc)))
-	      ;; We got an error back from the STARTTLS command.
-	      (progn
-		(if (eq type 'starttls)
-		    (progn
-		      (delete-process stream)
-		      nil)
-		  (list stream greeting capabilities 'network)))
-	    ;; The server said it was OK to start doing STARTTLS negotiations.
-	    (if (fboundp 'open-gnutls-stream)
-		(gnutls-negotiate stream nil)
-	      (unless (starttls-negotiate stream)
-		(delete-process stream)
-		(setq stream nil)))
-	    (when (or (null stream)
-		      (not (memq (process-status stream)
-				 '(open run))))
-	      ;; It didn't successfully negotiate STARTTLS, so we reopen
-	      ;; the connection.
-	      (setq stream (open-network-stream name buffer host service))
-	      (proto-stream-get-response stream start eoc))
-	    ;; Re-get the capabilities, since they may have changed
-	    ;; after switching to TLS.
-	    (list stream greeting
-		  (proto-stream-command stream capability-command eoc) 'tls)))
-	 ;; We don't have STARTTLS support available, but the caller
-	 ;; requested a STARTTLS connection, so we give up.
-	 ((eq (cadr (memq :type parameters)) 'starttls)
-	  (delete-process stream)
-	  nil)
-	 ;; Fall back on using a plain network stream.
-	 (t
-	  (list stream greeting capabilities 'network)))))))
+	 (capabilities (when capability-command
+			 (proto-stream-command stream
+					       capability-command eoc)))
+	 (resulting-type 'default)
+	 starttls-command)
+
+    ;; If we have STARTTLS support, try to upgrade the connection.
+    (when (and (or (fboundp 'open-gnutls-stream)
+		   (executable-find "gnutls-cli"))
+	       capabilities success-string starttls-function
+	       (setq starttls-command
+		     (funcall starttls-function capabilities)))
+      ;; If using external STARTTLS, drop this connection and start
+      ;; anew with `starttls-open-stream'.
+      (unless (fboundp 'open-gnutls-stream)
+	(delete-process stream)
+	(setq start (with-current-buffer buffer (point-max)))
+	(let* ((starttls-use-gnutls t)
+	       (starttls-extra-arguments
+		(if (not (eq type 'starttls))
+		    ;; For opportunistic TLS upgrades, we don't
+		    ;; really care about the identity of the peer.
+		    (cons "--insecure" starttls-extra-arguments)
+		  starttls-extra-arguments)))
+	  (setq stream (starttls-open-stream name buffer host service)))
+	(proto-stream-get-response stream start eoc))
+      (when (string-match success-string
+			  (proto-stream-command stream starttls-command eoc))
+	;; The server said it was OK to begin STARTTLS negotiations.
+	(if (fboundp 'open-gnutls-stream)
+	    (gnutls-negotiate stream nil)
+	  (unless (starttls-negotiate stream)
+	    (delete-process stream)))
+	(if (memq (process-status stream) '(open run))
+	    (setq resulting-type 'tls)
+	  ;; We didn't successfully negotiate STARTTLS; if TLS
+	  ;; isn't demanded, reopen an unencrypted connection.
+	  (when (eq type 'try-starttls)
+	    (setq stream (open-network-stream name buffer host service))
+	    (proto-stream-get-response stream start eoc)))
+	;; Re-get the capabilities, which may have now changed.
+	(setq capabilities
+	      (proto-stream-command stream capability-command eoc))))
+
+    ;; If TLS is mandatory, close the connection if it's unencrypted.
+    (and (eq type 'starttls)
+	 (eq resulting-type 'default)
+	 (delete-process stream))
+    ;; Return value:
+    (list stream greeting capabilities resulting-type)))
 
 (defun proto-stream-command (stream command eoc)
   (let ((start (with-current-buffer (process-buffer stream) (point-max))))
@@ -241,47 +234,43 @@ encrypted or not."
 	   (funcall (if (fboundp 'open-gnutls-stream)
 			'open-gnutls-stream
 		      'open-tls-stream)
-		    name buffer host service)))
+		    name buffer host service))
+	  (eoc (plist-get parameters :end-of-command)))
       (if (null stream)
-	  nil
+	  (list nil nil nil 'default)
 	;; If we're using tls.el, we have to delete the output from
 	;; openssl/gnutls-cli.
 	(unless (fboundp 'open-gnutls-stream)
-	  (proto-stream-get-response
-	   stream start (proto-stream-eoc parameters))
+	  (proto-stream-get-response stream start eoc)
 	  (goto-char (point-min))
-	  (when (re-search-forward (proto-stream-eoc parameters) nil t)
+	  (when (re-search-forward eoc nil t)
 	    (goto-char (match-beginning 0))
 	    (delete-region (point-min) (line-beginning-position))))
 	(proto-stream-capability-open start stream parameters 'tls)))))
 
 (defun proto-stream-open-shell (name buffer host service parameters)
+  (require 'format-spec)
   (proto-stream-capability-open
    (with-current-buffer buffer (point))
    (let ((process-connection-type nil))
      (start-process name buffer shell-file-name
 		    shell-command-switch
 		    (format-spec
-		     (cadr (memq :shell-command parameters))
+		     (plist-get parameters :shell-command)
 		     (format-spec-make
 		      ?s host
 		      ?p service))))
-   parameters 'network))
+   parameters 'default))
 
 (defun proto-stream-capability-open (start stream parameters stream-type)
-  (let ((capability-command (cadr (memq :capability-command parameters)))
-	(greeting (proto-stream-get-response
-		   stream start (proto-stream-eoc parameters))))
+  (let* ((capability-command (plist-get parameters :capability-command))
+	 (eoc 		     (plist-get parameters :end-of-command))
+	 (greeting (proto-stream-get-response stream start eoc)))
     (list stream greeting
 	  (and capability-command
-	       (proto-stream-command
-		stream capability-command (proto-stream-eoc parameters)))
+	       (proto-stream-command stream capability-command eoc))
 	  stream-type)))
 
-(defun proto-stream-eoc (parameters)
-  (or (cadr (memq :end-of-command parameters))
-      "\r\n"))
-
 (provide 'proto-stream)
 
 ;;; proto-stream.el ends here