cgit.sxemacs.org Git - gnus/blob - lisp/proto-stream.el

   1 ;;; proto-stream.el --- negotiating TLS, STARTTLS and other connections
   2
   3 ;; Copyright (C) 2010-2011 Free Software Foundation, Inc.
   4
   5 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
   6 ;; Keywords: network
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software: you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation, either version 3 of the License, or
  13 ;; (at your option) any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24
  25 ;; This library is meant to provide the glue between modules that want
  26 ;; to establish a network connection to a server for protocols such as
  27 ;; IMAP, NNTP, SMTP and POP3.
  28
  29 ;; The main problem is that there's more than a couple of interfaces
  30 ;; towards doing this.  You have normal, plain connections, which are
  31 ;; no trouble at all, but you also have TLS/SSL connections, and you
  32 ;; have STARTTLS.  Negotiating this for each protocol can be rather
  33 ;; tedious, so this library provides a single entry point, and hides
  34 ;; much of the ugliness.
  35
  36 ;; Usage example:
  37
  38 ;; (open-protocol-stream
  39 ;;  "*nnimap*" buffer address port
  40 ;;  :type 'network
  41 ;;  :capability-command "1 CAPABILITY\r\n"
  42 ;;  :success " OK "
  43 ;;  :starttls-function
  44 ;;  (lambda (capabilities)
  45 ;;    (if (not (string-match "STARTTLS" capabilities))
  46 ;;        nil
  47 ;;      "1 STARTTLS\r\n")))
  48
  49 ;;; Code:
  50
  51 (require 'tls)
  52 (require 'starttls)
  53
  54 (declare-function gnutls-negotiate "gnutls" t t) ; defun*
  55
  56 ;;;###autoload
  57 (defun open-protocol-stream (name buffer host service &rest parameters)
  58   "Open a network stream to HOST, possibly with encryption.
  59 Normally, return a network process object; with a non-nil
  60 :return-list parameter, return a list instead (see below).
  61
  62 The first four parameters, NAME, BUFFER, HOST, and SERVICE, have
  63 the same meanings as in `open-network-stream'.  The remaining
  64 PARAMETERS should be a sequence of keywords and values:
  65
  66 :type specifies the connection type, one of the following:
  67   nil or `network'
  68              -- Begin with an ordinary network connection, and if
  69                 the parameters :success and :capability-command
  70                 are also supplied, try to upgrade to an encrypted
  71                 connection via STARTTLS.  Even if that
  72                 fails (e.g. if HOST does not support TLS), retain
  73                 an unencrypted connection.
  74   `plain'    -- An ordinary, unencrypted network connection.
  75   `starttls' -- Begin with an ordinary connection, and try
  76                 upgrading via STARTTLS.  If that fails for any
  77                 reason, drop the connection; in that case the
  78                 returned object is a killed process.
  79   `tls'      -- A TLS connection.
  80   `ssl'      -- Equivalent to `tls'.
  81   `shell'    -- A shell connection.
  82
  83 :return-list specifies this function's return value.
  84   If omitted or nil, return a process object.  A non-nil means to
  85   return (PROC . PROPS), where PROC is a process object and PROPS
  86   is a plist of connection properties, with these keywords:
  87    :greeting -- the greeting returned by HOST (a string), or nil.
  88    :capabilities -- a string representing HOST's capabilities,
  89                     or nil if none could be found.
  90    :type -- the resulting connection type; `plain' (unencrypted)
  91             or `tls' (TLS-encrypted).
  92
  93 :end-of-command specifies a regexp matching the end of a command.
  94   If non-nil, it defaults to \"\\n\".
  95
  96 :success specifies a regexp matching a message indicating a
  97   successful STARTTLS negotiation.  For instance, the default
  98   should be \"^3\" for an NNTP connection.
  99
 100 :capability-command specifies a command used to query the HOST
 101   for its capabilities.  For instance, for IMAP this should be
 102   \"1 CAPABILITY\\r\\n\".
 103
 104 :starttls-function specifies a function for handling STARTTLS.
 105   This function should take one parameter, the response to the
 106   capability command, and should return the command to switch on
 107   STARTTLS if the server supports STARTTLS, and nil otherwise."
 108   (let ((type (plist-get parameters :type))
 109         (return-list (plist-get parameters :return-list)))
 110     (if (and (not return-list)
 111              (or (eq type 'plain)
 112                  (and (memq type '(nil network))
 113                       (not (and (plist-get parameters :success)
 114                                 (plist-get parameters :capability-command))))))
 115         ;; The simplest case is equivalent to `open-network-stream'.
 116         (open-network-stream name buffer host service)
 117       ;; For everything else, refer to proto-stream-open-*.
 118       (unless (plist-get parameters :end-of-command)
 119         (setq parameters (append '(:end-of-command "\r\n") parameters)))
 120       (let* ((connection-function
 121               (cond
 122                ((eq type 'plain) 'proto-stream-open-plain)
 123                ((memq type '(nil network starttls))
 124                 'proto-stream-open-starttls)
 125                ((memq type '(tls ssl)) 'proto-stream-open-tls)
 126                ((eq type 'shell) 'proto-stream-open-shell)
 127                (t (error "Invalid connection type %s" type))))
 128              (result (funcall connection-function
 129                               name buffer host service parameters)))
 130         (if return-list
 131             (list (car result)
 132                   :greeting     (nth 1 result)
 133                   :capabilities (nth 2 result)
 134                   :type         (nth 3 result))
 135           (car result))))))
 136
 137 (defun proto-stream-open-plain (name buffer host service parameters)
 138   (let ((start (with-current-buffer buffer (point)))
 139         (stream (open-network-stream name buffer host service)))
 140     (list stream
 141           (proto-stream-get-response stream start
 142                                      (plist-get parameters :end-of-command))
 143           nil
 144           'plain)))
 145
 146 (defun proto-stream-open-starttls (name buffer host service parameters)
 147   (let* ((start (with-current-buffer buffer (point)))
 148          (require-tls    (eq (plist-get parameters :type) 'starttls))
 149          (starttls-function  (plist-get parameters :starttls-function))
 150          (success-string     (plist-get parameters :success))
 151          (capability-command (plist-get parameters :capability-command))
 152          (eoc                (plist-get parameters :end-of-command))
 153          ;; Return (STREAM GREETING CAPABILITIES RESULTING-TYPE)
 154          (stream (open-network-stream name buffer host service))
 155          (greeting (proto-stream-get-response stream start eoc))
 156          (capabilities (when capability-command
 157                          (proto-stream-command stream
 158                                                capability-command eoc)))
 159          (resulting-type 'plain)
 160          starttls-command)
 161
 162     ;; If we have built-in STARTTLS support, try to upgrade the
 163     ;; connection.
 164     (when (and (or (fboundp 'open-gnutls-stream)
 165                    (and require-tls
 166                         (executable-find "gnutls-cli")))
 167                capabilities success-string starttls-function
 168                (setq starttls-command
 169                      (funcall starttls-function capabilities)))
 170       ;; If using external STARTTLS, drop this connection and start
 171       ;; anew with `starttls-open-stream'.
 172       (unless (fboundp 'open-gnutls-stream)
 173         (delete-process stream)
 174         (setq start (with-current-buffer buffer (point-max)))
 175         (let* ((starttls-use-gnutls t)
 176                (starttls-extra-arguments
 177                 (if require-tls
 178                     starttls-extra-arguments
 179                   ;; For opportunistic TLS upgrades, we don't really
 180                   ;; care about the identity of the peer.
 181                   (cons "--insecure" starttls-extra-arguments))))
 182           (setq stream (starttls-open-stream name buffer host service)))
 183         (proto-stream-get-response stream start eoc))
 184       (when (string-match success-string
 185                           (proto-stream-command stream starttls-command eoc))
 186         ;; The server said it was OK to begin STARTTLS negotiations.
 187         (if (fboundp 'open-gnutls-stream)
 188             (gnutls-negotiate :process stream :hostname host)
 189           (unless (starttls-negotiate stream)
 190             (delete-process stream)))
 191         (if (memq (process-status stream) '(open run))
 192             (setq resulting-type 'tls)
 193           ;; We didn't successfully negotiate STARTTLS; if TLS
 194           ;; isn't demanded, reopen an unencrypted connection.
 195           (unless require-tls
 196             (setq stream (open-network-stream name buffer host service))
 197             (proto-stream-get-response stream start eoc)))
 198         ;; Re-get the capabilities, which may have now changed.
 199         (setq capabilities
 200               (proto-stream-command stream capability-command eoc))))
 201
 202     ;; If TLS is mandatory, close the connection if it's unencrypted.
 203     (and require-tls
 204          (eq resulting-type 'plain)
 205          (delete-process stream))
 206     ;; Return value:
 207     (list stream greeting capabilities resulting-type)))
 208
 209 (defun proto-stream-command (stream command eoc)
 210   (let ((start (with-current-buffer (process-buffer stream) (point-max))))
 211     (process-send-string stream command)
 212     (proto-stream-get-response stream start eoc)))
 213
 214 (defun proto-stream-get-response (stream start end-of-command)
 215   (with-current-buffer (process-buffer stream)
 216     (save-excursion
 217       (goto-char start)
 218       (while (and (memq (process-status stream)
 219                         '(open run))
 220                   (not (re-search-forward end-of-command nil t)))
 221         (accept-process-output stream 0 50)
 222         (goto-char start))
 223       (if (= start (point))
 224           ;; The process died; return nil.
 225           nil
 226         ;; Return the data we got back.
 227         (buffer-substring start (point))))))
 228
 229 (defun proto-stream-open-tls (name buffer host service parameters)
 230   (with-current-buffer buffer
 231     (let ((start (point-max))
 232           (stream
 233            (funcall (if (fboundp 'open-gnutls-stream)
 234                         'open-gnutls-stream
 235                       'open-tls-stream)
 236                     name buffer host service))
 237           (eoc (plist-get parameters :end-of-command)))
 238       (if (null stream)
 239           (list nil nil nil 'plain)
 240         ;; If we're using tls.el, we have to delete the output from
 241         ;; openssl/gnutls-cli.
 242         (unless (fboundp 'open-gnutls-stream)
 243           (proto-stream-get-response stream start eoc)
 244           (goto-char (point-min))
 245           (when (re-search-forward eoc nil t)
 246             (goto-char (match-beginning 0))
 247             (delete-region (point-min) (line-beginning-position))))
 248         (proto-stream-capability-open start stream parameters 'tls)))))
 249
 250 (defun proto-stream-open-shell (name buffer host service parameters)
 251   (require 'format-spec)
 252   (proto-stream-capability-open
 253    (with-current-buffer buffer (point))
 254    (let ((process-connection-type nil))
 255      (start-process name buffer shell-file-name
 256                     shell-command-switch
 257                     (format-spec
 258                      (plist-get parameters :shell-command)
 259                      (format-spec-make
 260                       ?s host
 261                       ?p service))))
 262    parameters 'plain))
 263
 264 (defun proto-stream-capability-open (start stream parameters stream-type)
 265   (let* ((capability-command (plist-get parameters :capability-command))
 266          (eoc                (plist-get parameters :end-of-command))
 267          (greeting (proto-stream-get-response stream start eoc)))
 268     (list stream greeting
 269           (and capability-command
 270                (proto-stream-command stream capability-command eoc))
 271           stream-type)))
 272
 273 (provide 'proto-stream)
 274
 275 ;;; proto-stream.el ends here