cgit.sxemacs.org Git - gnus/blob - lisp/sieve-manage.el

   1 ;;; sieve-manage.el --- Implementation of the managesieve protocol in elisp
   2
   3 ;; Copyright (C) 2001-2013 Free Software Foundation, Inc.
   4
   5 ;; Author: Simon Josefsson <simon@josefsson.org>
   6 ;;         Albert Krewinkel <tarleb@moltkeplatz.de>
   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 provides an elisp API for the managesieve network
  26 ;; protocol.
  27 ;;
  28 ;; It uses the SASL library for authentication, which means it
  29 ;; supports DIGEST-MD5, CRAM-MD5, SCRAM-MD5, NTLM, PLAIN and LOGIN
  30 ;; methods.  STARTTLS is not well tested, but should be easy to get to
  31 ;; work if someone wants.
  32 ;;
  33 ;; The API should be fairly obvious for anyone familiar with the
  34 ;; managesieve protocol, interface functions include:
  35 ;;
  36 ;; `sieve-manage-open'
  37 ;; open connection to managesieve server, returning a buffer to be
  38 ;; used by all other API functions.
  39 ;;
  40 ;; `sieve-manage-opened'
  41 ;; check if a server is open or not
  42 ;;
  43 ;; `sieve-manage-close'
  44 ;; close a server connection.
  45 ;;
  46 ;; `sieve-manage-listscripts'
  47 ;; `sieve-manage-deletescript'
  48 ;; `sieve-manage-getscript'
  49 ;; performs managesieve protocol actions
  50 ;;
  51 ;; and that's it.  Example of a managesieve session in *scratch*:
  52 ;;
  53 ;; (with-current-buffer (sieve-manage-open "mail.example.com")
  54 ;;   (sieve-manage-authenticate)
  55 ;;   (sieve-manage-listscripts))
  56 ;;
  57 ;; => ((active . "main") "vacation")
  58 ;;
  59 ;; References:
  60 ;;
  61 ;; draft-martin-managesieve-02.txt,
  62 ;; "A Protocol for Remotely Managing Sieve Scripts",
  63 ;; by Tim Martin.
  64 ;;
  65 ;; Release history:
  66 ;;
  67 ;; 2001-10-31 Committed to Oort Gnus.
  68 ;; 2002-07-27 Added DELETESCRIPT.  Suggested by Ned Ludd.
  69 ;; 2002-08-03 Use SASL library.
  70 ;; 2013-06-05 Enabled STARTTLS support, fixed bit rot.
  71
  72 ;;; Code:
  73
  74 ;; For Emacs <22.2 and XEmacs.
  75 (eval-and-compile
  76   (unless (fboundp 'declare-function) (defmacro declare-function (&rest r))))
  77
  78 (if (locate-library "password-cache")
  79     (require 'password-cache)
  80   (require 'password))
  81
  82 (eval-when-compile
  83   (require 'cl)                         ; caddr
  84   (require 'sasl)
  85   (require 'starttls))
  86 (autoload 'sasl-find-mechanism "sasl")
  87 (autoload 'auth-source-search "auth-source")
  88
  89 ;; User customizable variables:
  90
  91 (defgroup sieve-manage nil
  92   "Low-level Managesieve protocol issues."
  93   :group 'mail
  94   :prefix "sieve-")
  95
  96 (defcustom sieve-manage-log "*sieve-manage-log*"
  97   "Name of buffer for managesieve session trace."
  98   :type 'string
  99   :group 'sieve-manage)
 100
 101 (defcustom sieve-manage-server-eol "\r\n"
 102   "The EOL string sent from the server."
 103   :type 'string
 104   :group 'sieve-manage)
 105
 106 (defcustom sieve-manage-client-eol "\r\n"
 107   "The EOL string we send to the server."
 108   :type 'string
 109   :group 'sieve-manage)
 110
 111 (defcustom sieve-manage-authenticators '(digest-md5
 112                                          cram-md5
 113                                          scram-md5
 114                                          ntlm
 115                                          plain
 116                                          login)
 117   "Priority of authenticators to consider when authenticating to server."
 118   :group 'sieve-manage)
 119
 120 (defcustom sieve-manage-authenticator-alist
 121   '((cram-md5   sieve-manage-cram-md5-p       sieve-manage-cram-md5-auth)
 122     (digest-md5 sieve-manage-digest-md5-p     sieve-manage-digest-md5-auth)
 123     (scram-md5  sieve-manage-scram-md5-p      sieve-manage-scram-md5-auth)
 124     (ntlm       sieve-manage-ntlm-p           sieve-manage-ntlm-auth)
 125     (plain      sieve-manage-plain-p          sieve-manage-plain-auth)
 126     (login      sieve-manage-login-p          sieve-manage-login-auth))
 127   "Definition of authenticators.
 128
 129 \(NAME CHECK AUTHENTICATE)
 130
 131 NAME names the authenticator.  CHECK is a function returning non-nil if
 132 the server support the authenticator and AUTHENTICATE is a function
 133 for doing the actual authentication."
 134   :group 'sieve-manage)
 135
 136 (defcustom sieve-manage-default-port "sieve"
 137   "Default port number or service name for managesieve protocol."
 138   :type '(choice integer string)
 139   :version "24.4"
 140   :group 'sieve-manage)
 141
 142 (defcustom sieve-manage-default-stream 'network
 143   "Default stream type to use for `sieve-manage'."
 144   :version "24.1"
 145   :type 'symbol
 146   :group 'sieve-manage)
 147
 148 ;; Internal variables:
 149
 150 (defconst sieve-manage-local-variables '(sieve-manage-server
 151                                          sieve-manage-port
 152                                          sieve-manage-auth
 153                                          sieve-manage-stream
 154                                          sieve-manage-process
 155                                          sieve-manage-client-eol
 156                                          sieve-manage-server-eol
 157                                          sieve-manage-capability))
 158 (defconst sieve-manage-coding-system-for-read 'binary)
 159 (defconst sieve-manage-coding-system-for-write 'binary)
 160 (defvar sieve-manage-stream nil)
 161 (defvar sieve-manage-auth nil)
 162 (defvar sieve-manage-server nil)
 163 (defvar sieve-manage-port nil)
 164 (defvar sieve-manage-state 'closed
 165   "Managesieve state.
 166 Valid states are `closed', `initial', `nonauth', and `auth'.")
 167 (defvar sieve-manage-process nil)
 168 (defvar sieve-manage-capability nil)
 169
 170 ;; Internal utility functions
 171 (autoload 'mm-enable-multibyte "mm-util")
 172
 173 (defun sieve-manage-make-process-buffer ()
 174   (with-current-buffer
 175       (generate-new-buffer (format " *sieve %s:%s*"
 176                                    sieve-manage-server
 177                                    sieve-manage-port))
 178     (mapc 'make-local-variable sieve-manage-local-variables)
 179     (mm-enable-multibyte)
 180     (buffer-disable-undo)
 181     (current-buffer)))
 182
 183 (defun sieve-manage-erase (&optional p buffer)
 184   (let ((buffer (or buffer (current-buffer))))
 185     (and sieve-manage-log
 186          (with-current-buffer (get-buffer-create sieve-manage-log)
 187            (mm-enable-multibyte)
 188            (buffer-disable-undo)
 189            (goto-char (point-max))
 190            (insert-buffer-substring buffer (with-current-buffer buffer
 191                                              (point-min))
 192                                     (or p (with-current-buffer buffer
 193                                             (point-max)))))))
 194   (delete-region (point-min) (or p (point-max))))
 195
 196 (defun sieve-manage-open-server (server port &optional stream buffer)
 197   "Open network connection to SERVER on PORT.
 198 Return the buffer associated with the connection."
 199   (with-current-buffer buffer
 200     (sieve-manage-erase)
 201     (setq sieve-manage-state 'initial)
 202     (destructuring-bind (proc . props)
 203         (open-protocol-stream
 204          "SIEVE" buffer server port
 205          :type stream
 206          :capability-command "CAPABILITY\r\n"
 207          :end-of-command "^\\(OK\\|NO\\).*\n"
 208          :success "^OK.*\n"
 209          :return-list t
 210          :starttls-function
 211          (lambda (capabilities)
 212            (when (string-match "\\bSTARTTLS\\b" capabilities)
 213              "STARTTLS\r\n")))
 214       (setq sieve-manage-process proc)
 215       (setq sieve-manage-capability
 216             (sieve-manage-parse-capability (plist-get props :capabilities)))
 217       ;; Ignore new capabilities issues after successful STARTTLS
 218       (when (and (memq stream '(nil network starttls))
 219                  (eq (plist-get props :type) 'tls))
 220         (sieve-manage-drop-next-answer))
 221       (current-buffer))))
 222
 223 ;; Authenticators
 224 (defun sieve-sasl-auth (buffer mech)
 225   "Login to server using the SASL MECH method."
 226   (message "sieve: Authenticating using %s..." mech)
 227   (with-current-buffer buffer
 228     (let* ((auth-info (auth-source-search :host sieve-manage-server
 229                                           :port "sieve"
 230                                           :max 1
 231                                           :create t))
 232            (user-name (or (plist-get (nth 0 auth-info) :user) ""))
 233            (user-password (or (plist-get (nth 0 auth-info) :secret) ""))
 234            (user-password (if (functionp user-password)
 235                               (funcall user-password)
 236                             user-password))
 237            (client (sasl-make-client (sasl-find-mechanism (list mech))
 238                                      user-name "sieve" sieve-manage-server))
 239            (sasl-read-passphrase
 240             ;; We *need* to copy the password, because sasl will modify it
 241             ;; somehow.
 242             `(lambda (prompt) ,(copy-sequence user-password)))
 243            (step (sasl-next-step client nil))
 244            (tag (sieve-manage-send
 245                  (concat
 246                   "AUTHENTICATE \""
 247                   mech
 248                   "\""
 249                   (and (sasl-step-data step)
 250                        (concat
 251                         " \""
 252                         (base64-encode-string
 253                          (sasl-step-data step)
 254                          'no-line-break)
 255                         "\"")))))
 256            data rsp)
 257       (catch 'done
 258         (while t
 259           (setq rsp nil)
 260           (goto-char (point-min))
 261           (while (null (or (progn
 262                              (setq rsp (sieve-manage-is-string))
 263                              (if (not (and rsp (looking-at
 264                                                 sieve-manage-server-eol)))
 265                                  (setq rsp nil)
 266                                (goto-char (match-end 0))
 267                                rsp))
 268                            (setq rsp (sieve-manage-is-okno))))
 269             (accept-process-output sieve-manage-process 1)
 270             (goto-char (point-min)))
 271           (sieve-manage-erase)
 272           (when (sieve-manage-ok-p rsp)
 273             (when (and (cadr rsp)
 274                        (string-match "^SASL \"\\([^\"]+\\)\"" (cadr rsp)))
 275               (sasl-step-set-data
 276                step (base64-decode-string (match-string 1 (cadr rsp)))))
 277             (if (and (setq step (sasl-next-step client step))
 278                      (setq data (sasl-step-data step)))
 279                 ;; We got data for server but it's finished
 280                 (error "Server not ready for SASL data: %s" data)
 281               ;; The authentication process is finished.
 282               (throw 'done t)))
 283           (unless (stringp rsp)
 284             (error "Server aborted SASL authentication: %s" (caddr rsp)))
 285           (sasl-step-set-data step (base64-decode-string rsp))
 286           (setq step (sasl-next-step client step))
 287           (sieve-manage-send
 288            (if (sasl-step-data step)
 289                (concat "\""
 290                        (base64-encode-string (sasl-step-data step)
 291                                              'no-line-break)
 292                        "\"")
 293              ""))))
 294       (message "sieve: Login using %s...done" mech))))
 295
 296 (defun sieve-manage-cram-md5-p (buffer)
 297   (sieve-manage-capability "SASL" "CRAM-MD5" buffer))
 298
 299 (defun sieve-manage-cram-md5-auth (buffer)
 300   "Login to managesieve server using the CRAM-MD5 SASL method."
 301   (sieve-sasl-auth buffer "CRAM-MD5"))
 302
 303 (defun sieve-manage-digest-md5-p (buffer)
 304   (sieve-manage-capability "SASL" "DIGEST-MD5" buffer))
 305
 306 (defun sieve-manage-digest-md5-auth (buffer)
 307   "Login to managesieve server using the DIGEST-MD5 SASL method."
 308   (sieve-sasl-auth buffer "DIGEST-MD5"))
 309
 310 (defun sieve-manage-scram-md5-p (buffer)
 311   (sieve-manage-capability "SASL" "SCRAM-MD5" buffer))
 312
 313 (defun sieve-manage-scram-md5-auth (buffer)
 314   "Login to managesieve server using the SCRAM-MD5 SASL method."
 315   (sieve-sasl-auth buffer "SCRAM-MD5"))
 316
 317 (defun sieve-manage-ntlm-p (buffer)
 318   (sieve-manage-capability "SASL" "NTLM" buffer))
 319
 320 (defun sieve-manage-ntlm-auth (buffer)
 321   "Login to managesieve server using the NTLM SASL method."
 322   (sieve-sasl-auth buffer "NTLM"))
 323
 324 (defun sieve-manage-plain-p (buffer)
 325   (sieve-manage-capability "SASL" "PLAIN" buffer))
 326
 327 (defun sieve-manage-plain-auth (buffer)
 328   "Login to managesieve server using the PLAIN SASL method."
 329   (sieve-sasl-auth buffer "PLAIN"))
 330
 331 (defun sieve-manage-login-p (buffer)
 332   (sieve-manage-capability "SASL" "LOGIN" buffer))
 333
 334 (defun sieve-manage-login-auth (buffer)
 335   "Login to managesieve server using the LOGIN SASL method."
 336   (sieve-sasl-auth buffer "LOGIN"))
 337
 338 ;; Managesieve API
 339
 340 (defun sieve-manage-open (server &optional port stream auth buffer)
 341   "Open a network connection to a managesieve SERVER (string).
 342 Optional argument PORT is port number (integer) on remote server.
 343 Optional argument STREAM is any of `sieve-manage-streams' (a symbol).
 344 Optional argument AUTH indicates authenticator to use, see
 345 `sieve-manage-authenticators' for available authenticators.
 346 If nil, chooses the best stream the server is capable of.
 347 Optional argument BUFFER is buffer (buffer, or string naming buffer)
 348 to work in."
 349   (setq sieve-manage-port (or port sieve-manage-default-port))
 350   (with-current-buffer (or buffer (sieve-manage-make-process-buffer))
 351     (setq sieve-manage-server (or server
 352                                   sieve-manage-server)
 353           sieve-manage-stream (or stream
 354                                   sieve-manage-stream
 355                                   sieve-manage-default-stream)
 356           sieve-manage-auth   (or auth
 357                                   sieve-manage-auth))
 358     (message "sieve: Connecting to %s..." sieve-manage-server)
 359     (sieve-manage-open-server sieve-manage-server
 360                               sieve-manage-port
 361                               sieve-manage-stream
 362                               (current-buffer))
 363     (when (sieve-manage-opened (current-buffer))
 364       ;; Choose authenticator
 365       (when (and (null sieve-manage-auth)
 366                  (not (eq sieve-manage-state 'auth)))
 367         (dolist (auth sieve-manage-authenticators)
 368           (when (funcall (nth 1 (assq auth sieve-manage-authenticator-alist))
 369                        buffer)
 370             (setq sieve-manage-auth auth)
 371             (return)))
 372         (unless sieve-manage-auth
 373           (error "Couldn't figure out authenticator for server")))
 374       (sieve-manage-erase)
 375       (current-buffer))))
 376
 377 (defun sieve-manage-authenticate (&optional buffer)
 378   "Authenticate on server in BUFFER.
 379 Return `sieve-manage-state' value."
 380   (with-current-buffer (or buffer (current-buffer))
 381     (if (eq sieve-manage-state 'nonauth)
 382         (when (funcall (nth 2 (assq sieve-manage-auth
 383                                     sieve-manage-authenticator-alist))
 384                        (current-buffer))
 385           (setq sieve-manage-state 'auth))
 386       sieve-manage-state)))
 387
 388 (defun sieve-manage-opened (&optional buffer)
 389   "Return non-nil if connection to managesieve server in BUFFER is open.
 390 If BUFFER is nil then the current buffer is used."
 391   (and (setq buffer (get-buffer (or buffer (current-buffer))))
 392        (buffer-live-p buffer)
 393        (with-current-buffer buffer
 394          (and sieve-manage-process
 395               (memq (process-status sieve-manage-process) '(open run))))))
 396
 397 (defun sieve-manage-close (&optional buffer)
 398   "Close connection to managesieve server in BUFFER.
 399 If BUFFER is nil, the current buffer is used."
 400   (with-current-buffer (or buffer (current-buffer))
 401     (when (sieve-manage-opened)
 402       (sieve-manage-send "LOGOUT")
 403       (sit-for 1))
 404     (when (and sieve-manage-process
 405                (memq (process-status sieve-manage-process) '(open run)))
 406       (delete-process sieve-manage-process))
 407     (setq sieve-manage-process nil)
 408     (sieve-manage-erase)
 409     t))
 410
 411 (defun sieve-manage-capability (&optional name value buffer)
 412   "Check if capability NAME of server BUFFER match VALUE.
 413 If it does, return the server value of NAME. If not returns nil.
 414 If VALUE is nil, do not check VALUE and return server value.
 415 If NAME is nil, return the full server list of capabilities."
 416   (with-current-buffer (or buffer (current-buffer))
 417     (if (null name)
 418         sieve-manage-capability
 419       (let ((server-value (cadr (assoc name sieve-manage-capability))))
 420         (when (or (null value)
 421                   (and server-value
 422                        (string-match value server-value)))
 423           server-value)))))
 424
 425 (defun sieve-manage-listscripts (&optional buffer)
 426   (with-current-buffer (or buffer (current-buffer))
 427     (sieve-manage-send "LISTSCRIPTS")
 428     (sieve-manage-parse-listscripts)))
 429
 430 (defun sieve-manage-havespace (name size &optional buffer)
 431   (with-current-buffer (or buffer (current-buffer))
 432     (sieve-manage-send (format "HAVESPACE \"%s\" %s" name size))
 433     (sieve-manage-parse-okno)))
 434
 435 (defun sieve-manage-putscript (name content &optional buffer)
 436   (with-current-buffer (or buffer (current-buffer))
 437     (sieve-manage-send (format "PUTSCRIPT \"%s\" {%d+}%s%s" name
 438                                ;; Here we assume that the coding-system will
 439                                ;; replace each char with a single byte.
 440                                ;; This is always the case if `content' is
 441                                ;; a unibyte string.
 442                                (length content)
 443                                sieve-manage-client-eol content))
 444     (sieve-manage-parse-okno)))
 445
 446 (defun sieve-manage-deletescript (name &optional buffer)
 447   (with-current-buffer (or buffer (current-buffer))
 448     (sieve-manage-send (format "DELETESCRIPT \"%s\"" name))
 449     (sieve-manage-parse-okno)))
 450
 451 (defun sieve-manage-getscript (name output-buffer &optional buffer)
 452   (with-current-buffer (or buffer (current-buffer))
 453     (sieve-manage-send (format "GETSCRIPT \"%s\"" name))
 454     (let ((script (sieve-manage-parse-string)))
 455       (sieve-manage-parse-crlf)
 456       (with-current-buffer output-buffer
 457         (insert script))
 458       (sieve-manage-parse-okno))))
 459
 460 (defun sieve-manage-setactive (name &optional buffer)
 461   (with-current-buffer (or buffer (current-buffer))
 462     (sieve-manage-send (format "SETACTIVE \"%s\"" name))
 463     (sieve-manage-parse-okno)))
 464
 465 ;; Protocol parsing routines
 466
 467 (defun sieve-manage-wait-for-answer ()
 468   (let ((pattern "^\\(OK\\|NO\\).*\n")
 469         pos)
 470     (while (not pos)
 471       (setq pos (search-forward-regexp pattern nil t))
 472       (goto-char (point-min))
 473       (sleep-for 0 50))
 474     pos))
 475
 476 (defun sieve-manage-drop-next-answer ()
 477   (sieve-manage-wait-for-answer)
 478   (sieve-manage-erase))
 479
 480 (defun sieve-manage-ok-p (rsp)
 481   (string= (downcase (or (car-safe rsp) "")) "ok"))
 482
 483 (defun sieve-manage-is-okno ()
 484   (when (looking-at (concat
 485                      "^\\(OK\\|NO\\)\\( (\\([^)]+\\))\\)?\\( \\(.*\\)\\)?"
 486                      sieve-manage-server-eol))
 487     (let ((status (match-string 1))
 488           (resp-code (match-string 3))
 489           (response (match-string 5)))
 490       (when response
 491         (goto-char (match-beginning 5))
 492         (setq response (sieve-manage-is-string)))
 493       (list status resp-code response))))
 494
 495 (defun sieve-manage-parse-okno ()
 496   (let (rsp)
 497     (while (null rsp)
 498       (accept-process-output (get-buffer-process (current-buffer)) 1)
 499       (goto-char (point-min))
 500       (setq rsp (sieve-manage-is-okno)))
 501     (sieve-manage-erase)
 502     rsp))
 503
 504 (defun sieve-manage-parse-capability (str)
 505   "Parse managesieve capability string `STR'.
 506 Set variable `sieve-manage-capability' to "
 507   (let ((capas (delq nil
 508                      (mapcar #'split-string-and-unquote
 509                              (split-string str "\n")))))
 510     (when (string= "OK" (caar (last capas)))
 511       (setq sieve-manage-state 'nonauth))
 512     capas))
 513
 514 (defun sieve-manage-is-string ()
 515   (cond ((looking-at "\"\\([^\"]+\\)\"")
 516          (prog1
 517              (match-string 1)
 518            (goto-char (match-end 0))))
 519         ((looking-at (concat "{\\([0-9]+\\+?\\)}" sieve-manage-server-eol))
 520          (let ((pos (match-end 0))
 521                (len (string-to-number (match-string 1))))
 522            (if (< (point-max) (+ pos len))
 523                nil
 524              (goto-char (+ pos len))
 525              (buffer-substring pos (+ pos len)))))))
 526
 527 (defun sieve-manage-parse-string ()
 528   (let (rsp)
 529     (while (null rsp)
 530       (accept-process-output (get-buffer-process (current-buffer)) 1)
 531       (goto-char (point-min))
 532       (setq rsp (sieve-manage-is-string)))
 533     (sieve-manage-erase (point))
 534     rsp))
 535
 536 (defun sieve-manage-parse-crlf ()
 537   (when (looking-at sieve-manage-server-eol)
 538     (sieve-manage-erase (match-end 0))))
 539
 540 (defun sieve-manage-parse-listscripts ()
 541   (let (tmp rsp data)
 542     (while (null rsp)
 543       (while (null (or (setq rsp (sieve-manage-is-okno))
 544                        (setq tmp (sieve-manage-is-string))))
 545         (accept-process-output (get-buffer-process (current-buffer)) 1)
 546         (goto-char (point-min)))
 547       (when tmp
 548         (while (not (looking-at (concat "\\( ACTIVE\\)?"
 549                                         sieve-manage-server-eol)))
 550           (accept-process-output (get-buffer-process (current-buffer)) 1)
 551           (goto-char (point-min)))
 552         (if (match-string 1)
 553             (push (cons 'active tmp) data)
 554           (push tmp data))
 555         (goto-char (match-end 0))
 556         (setq tmp nil)))
 557     (sieve-manage-erase)
 558     (if (sieve-manage-ok-p rsp)
 559         data
 560       rsp)))
 561
 562 (defun sieve-manage-send (cmdstr)
 563   (setq cmdstr (concat cmdstr sieve-manage-client-eol))
 564   (and sieve-manage-log
 565        (with-current-buffer (get-buffer-create sieve-manage-log)
 566          (mm-enable-multibyte)
 567          (buffer-disable-undo)
 568          (goto-char (point-max))
 569          (insert cmdstr)))
 570   (process-send-string sieve-manage-process cmdstr))
 571
 572 (provide 'sieve-manage)
 573
 574 ;; sieve-manage.el ends here