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

   1 ;;; sieve-manage.el --- Implementation of the managesive protocol in elisp
   2
   3 ;; Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4 ;;   2008, 2009, 2010  Free Software Foundation, Inc.
   5
   6 ;; Author: Simon Josefsson <simon@josefsson.org>
   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-authenticate'
  47 ;; `sieve-manage-listscripts'
  48 ;; `sieve-manage-deletescript'
  49 ;; `sieve-manage-getscript'
  50 ;; performs managesieve protocol actions
  51 ;;
  52 ;; and that's it.  Example of a managesieve session in *scratch*:
  53 ;;
  54 ;; (setq my-buf (sieve-manage-open "my.server.com"))
  55 ;; " *sieve* my.server.com:2000*"
  56 ;;
  57 ;; (sieve-manage-authenticate "myusername" "mypassword" my-buf)
  58 ;; 'auth
  59 ;;
  60 ;; (sieve-manage-listscripts my-buf)
  61 ;; ("vacation" "testscript" ("splitmail") "badscript")
  62 ;;
  63 ;; References:
  64 ;;
  65 ;; draft-martin-managesieve-02.txt,
  66 ;; "A Protocol for Remotely Managing Sieve Scripts",
  67 ;; by Tim Martin.
  68 ;;
  69 ;; Release history:
  70 ;;
  71 ;; 2001-10-31 Committed to Oort Gnus.
  72 ;; 2002-07-27 Added DELETESCRIPT.  Suggested by Ned Ludd.
  73 ;; 2002-08-03 Use SASL library.
  74
  75 ;;; Code:
  76
  77 ;; For Emacs < 22.2.
  78 (eval-and-compile
  79   (unless (fboundp 'declare-function) (defmacro declare-function (&rest r))))
  80
  81 (if (locate-library "password-cache")
  82     (require 'password-cache)
  83   (require 'password))
  84
  85 (eval-when-compile
  86   (require 'sasl)
  87   (require 'starttls))
  88 (autoload 'sasl-find-mechanism "sasl")
  89 (autoload 'starttls-open-stream "starttls")
  90
  91 ;; User customizable variables:
  92
  93 (defgroup sieve-manage nil
  94   "Low-level Managesieve protocol issues."
  95   :group 'mail
  96   :prefix "sieve-")
  97
  98 (defcustom sieve-manage-log "*sieve-manage-log*"
  99   "Name of buffer for managesieve session trace."
 100   :type 'string
 101   :group 'sieve-manage)
 102
 103 (defcustom sieve-manage-default-user (user-login-name)
 104   "Default username to use."
 105   :type 'string
 106   :group 'sieve-manage)
 107
 108 (defcustom sieve-manage-server-eol "\r\n"
 109   "The EOL string sent from the server."
 110   :type 'string
 111   :group 'sieve-manage)
 112
 113 (defcustom sieve-manage-client-eol "\r\n"
 114   "The EOL string we send to the server."
 115   :type 'string
 116   :group 'sieve-manage)
 117
 118 (defcustom sieve-manage-streams '(network starttls shell)
 119   "Priority of streams to consider when opening connection to server."
 120   :group 'sieve-manage)
 121
 122 (defcustom sieve-manage-stream-alist
 123   '((network   sieve-manage-network-p          sieve-manage-network-open)
 124     (shell     sieve-manage-shell-p            sieve-manage-shell-open)
 125     (starttls  sieve-manage-starttls-p         sieve-manage-starttls-open))
 126   "Definition of network streams.
 127
 128 \(NAME CHECK OPEN)
 129
 130 NAME names the stream, CHECK is a function returning non-nil if the
 131 server support the stream and OPEN is a function for opening the
 132 stream."
 133   :group 'sieve-manage)
 134
 135 (defcustom sieve-manage-authenticators '(digest-md5
 136                                          cram-md5
 137                                          scram-md5
 138                                          ntlm
 139                                          plain
 140                                          login)
 141   "Priority of authenticators to consider when authenticating to server."
 142   :group 'sieve-manage)
 143
 144 (defcustom sieve-manage-authenticator-alist
 145   '((cram-md5   sieve-manage-cram-md5-p       sieve-manage-cram-md5-auth)
 146     (digest-md5 sieve-manage-digest-md5-p     sieve-manage-digest-md5-auth)
 147     (scram-md5  sieve-manage-scram-md5-p      sieve-manage-scram-md5-auth)
 148     (ntlm       sieve-manage-ntlm-p           sieve-manage-ntlm-auth)
 149     (plain      sieve-manage-plain-p          sieve-manage-plain-auth)
 150     (login      sieve-manage-login-p          sieve-manage-login-auth))
 151   "Definition of authenticators.
 152
 153 \(NAME CHECK AUTHENTICATE)
 154
 155 NAME names the authenticator.  CHECK is a function returning non-nil if
 156 the server support the authenticator and AUTHENTICATE is a function
 157 for doing the actual authentication."
 158   :group 'sieve-manage)
 159
 160 (defcustom sieve-manage-default-port 2000
 161   "Default port number for managesieve protocol."
 162   :type 'integer
 163   :group 'sieve-manage)
 164
 165 (defcustom sieve-manage-default-stream 'network
 166   "Default stream type to use for `sieve-manage'.
 167 Must be a name of a stream in `sieve-manage-stream-alist'."
 168   :type 'symbol
 169   :group 'sieve-manage)
 170
 171 ;; Internal variables:
 172
 173 (defconst sieve-manage-local-variables '(sieve-manage-server
 174                                          sieve-manage-port
 175                                          sieve-manage-auth
 176                                          sieve-manage-stream
 177                                          sieve-manage-username
 178                                          sieve-manage-password
 179                                          sieve-manage-process
 180                                          sieve-manage-client-eol
 181                                          sieve-manage-server-eol
 182                                          sieve-manage-capability))
 183 (defconst sieve-manage-coding-system-for-read 'binary)
 184 (defconst sieve-manage-coding-system-for-write 'binary)
 185 (defvar sieve-manage-stream nil)
 186 (defvar sieve-manage-auth nil)
 187 (defvar sieve-manage-server nil)
 188 (defvar sieve-manage-port nil)
 189 (defvar sieve-manage-username nil)
 190 (defvar sieve-manage-password nil)
 191 (defvar sieve-manage-state 'closed
 192   "Managesieve state.
 193 Valid states are `closed', `initial', `nonauth', and `auth'.")
 194 (defvar sieve-manage-process nil)
 195 (defvar sieve-manage-capability nil)
 196
 197 ;; Internal utility functions
 198
 199 (defmacro sieve-manage-disable-multibyte ()
 200   "Enable multibyte in the current buffer."
 201   (unless (featurep 'xemacs)
 202     '(set-buffer-multibyte nil)))
 203
 204 (declare-function password-read         "password-cache" (prompt &optional key))
 205 (declare-function password-cache-add    "password-cache" (key password))
 206 (declare-function password-cache-remove "password-cache" (key))
 207
 208 ;; Uses the dynamically bound `reason' variable.
 209 (defvar reason)
 210 (defun sieve-manage-interactive-login (buffer loginfunc)
 211   "Login to server in BUFFER.
 212 LOGINFUNC is passed a username and a password, it should return t if
 213 it was successful authenticating itself to the server, nil otherwise.
 214 Returns t if login was successful, nil otherwise."
 215   (with-current-buffer buffer
 216     (make-local-variable 'sieve-manage-username)
 217     (make-local-variable 'sieve-manage-password)
 218     (let (user passwd ret reason passwd-key)
 219       (condition-case ()
 220           (while (or (not user) (not passwd))
 221             (setq user (or sieve-manage-username
 222                            (read-from-minibuffer
 223                             (concat "Managesieve username for "
 224                                     sieve-manage-server ": ")
 225                             (or user sieve-manage-default-user)))
 226                   passwd-key (concat "managesieve:" user "@" sieve-manage-server
 227                                      ":" sieve-manage-port)
 228                   passwd (or sieve-manage-password
 229                              (password-read (concat "Managesieve password for "
 230                                                     user "@" sieve-manage-server
 231                                                     ": ")
 232                                             passwd-key)))
 233             (when (y-or-n-p "Store password for this session? ")
 234               (password-cache-add passwd-key (copy-sequence passwd)))
 235             (when (and user passwd)
 236               (if (funcall loginfunc user passwd)
 237                   (setq ret t
 238                         sieve-manage-username user)
 239                 (if reason
 240                     (message "Login failed (reason given: %s)..." reason)
 241                   (message "Login failed..."))
 242                 (password-cache-remove passwd-key)
 243                 (setq sieve-manage-password nil)
 244                 (setq passwd nil)
 245                 (setq reason nil)
 246                 (sit-for 1))))
 247         (quit (with-current-buffer buffer
 248                 (password-cache-remove passwd-key)
 249                 (setq user nil
 250                       passwd nil
 251                       sieve-manage-password nil)))
 252         (error (with-current-buffer buffer
 253                  (password-cache-remove passwd-key)
 254                  (setq user nil
 255                        passwd nil
 256                        sieve-manage-password nil))))
 257       ret)))
 258
 259 (defun sieve-manage-erase (&optional p buffer)
 260   (let ((buffer (or buffer (current-buffer))))
 261     (and sieve-manage-log
 262          (with-current-buffer (get-buffer-create sieve-manage-log)
 263            (sieve-manage-disable-multibyte)
 264            (buffer-disable-undo)
 265            (goto-char (point-max))
 266            (insert-buffer-substring buffer (with-current-buffer buffer
 267                                              (point-min))
 268                                     (or p (with-current-buffer buffer
 269                                             (point-max)))))))
 270   (delete-region (point-min) (or p (point-max))))
 271
 272 (defun sieve-manage-open-1 (buffer)
 273   (with-current-buffer buffer
 274     (sieve-manage-erase)
 275     (setq sieve-manage-state 'initial
 276           sieve-manage-process
 277           (condition-case ()
 278               (funcall (nth 2 (assq sieve-manage-stream
 279                                     sieve-manage-stream-alist))
 280                        "sieve" buffer sieve-manage-server sieve-manage-port)
 281             ((error quit) nil)))
 282     (when sieve-manage-process
 283       (while (and (eq sieve-manage-state 'initial)
 284                   (memq (process-status sieve-manage-process) '(open run)))
 285         (message "Waiting for response from %s..." sieve-manage-server)
 286         (accept-process-output sieve-manage-process 1))
 287       (message "Waiting for response from %s...done" sieve-manage-server)
 288       (and (memq (process-status sieve-manage-process) '(open run))
 289            sieve-manage-process))))
 290
 291 ;; Streams
 292
 293 (defun sieve-manage-network-p (buffer)
 294   t)
 295
 296 (defun sieve-manage-network-open (name buffer server port)
 297   (let* ((port (or port sieve-manage-default-port))
 298          (coding-system-for-read sieve-manage-coding-system-for-read)
 299          (coding-system-for-write sieve-manage-coding-system-for-write)
 300          (process (open-network-stream name buffer server port)))
 301     (when process
 302       (while (and (memq (process-status process) '(open run))
 303                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
 304                   (goto-char (point-min))
 305                   (not (sieve-manage-parse-greeting-1)))
 306         (accept-process-output process 1)
 307         (sit-for 1))
 308       (sieve-manage-erase nil buffer)
 309       (when (memq (process-status process) '(open run))
 310         process))))
 311
 312 (defun sieve-manage-starttls-p (buffer)
 313   (condition-case ()
 314       (progn
 315         (require 'starttls)
 316         (call-process "starttls"))
 317     (error nil)))
 318
 319 (defun sieve-manage-starttls-open (name buffer server port)
 320   (let* ((port (or port sieve-manage-default-port))
 321          (coding-system-for-read sieve-manage-coding-system-for-read)
 322          (coding-system-for-write sieve-manage-coding-system-for-write)
 323          (process (starttls-open-stream name buffer server port))
 324          done)
 325     (when process
 326       (while (and (memq (process-status process) '(open run))
 327                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
 328                   (goto-char (point-min))
 329                   (not (sieve-manage-parse-greeting-1)))
 330         (accept-process-output process 1)
 331         (sit-for 1))
 332       (sieve-manage-erase nil buffer)
 333       (sieve-manage-send "STARTTLS")
 334       (starttls-negotiate process))
 335     (when (memq (process-status process) '(open run))
 336       process)))
 337
 338 ;; Authenticators
 339
 340 (defun sieve-sasl-auth (buffer mech)
 341   "Login to server using the SASL MECH method."
 342   (message "sieve: Authenticating using %s..." mech)
 343   (if (sieve-manage-interactive-login
 344        buffer
 345        (lambda (user passwd)
 346          (let (client step tag data rsp)
 347            (setq client (sasl-make-client (sasl-find-mechanism (list mech))
 348                                           user "sieve" sieve-manage-server))
 349            (setq sasl-read-passphrase (function (lambda (prompt) passwd)))
 350            (setq step (sasl-next-step client nil))
 351            (setq tag
 352                  (sieve-manage-send
 353                   (concat
 354                    "AUTHENTICATE \""
 355                    mech
 356                    "\""
 357                    (and (sasl-step-data step)
 358                         (concat
 359                          " \""
 360                          (base64-encode-string
 361                           (sasl-step-data step)
 362                           'no-line-break)
 363                          "\"")))))
 364            (catch 'done
 365              (while t
 366                (setq rsp nil)
 367                (goto-char (point-min))
 368                (while (null (or (progn
 369                                   (setq rsp (sieve-manage-is-string))
 370                                   (if (not (and rsp (looking-at
 371                                                      sieve-manage-server-eol)))
 372                                       (setq rsp nil)
 373                                     (goto-char (match-end 0))
 374                                     rsp))
 375                                 (setq rsp (sieve-manage-is-okno))))
 376                  (accept-process-output sieve-manage-process 1)
 377                  (goto-char (point-min)))
 378                (sieve-manage-erase)
 379                (when (sieve-manage-ok-p rsp)
 380                  (when (string-match "^SASL \"\\([^\"]+\\)\"" (cadr rsp))
 381                    (sasl-step-set-data
 382                     step (base64-decode-string (match-string 1 (cadr rsp)))))
 383                  (if (and (setq step (sasl-next-step client step))
 384                           (setq data (sasl-step-data step)))
 385                      ;; We got data for server but it's finished
 386                      (error "Server not ready for SASL data: %s" data)
 387                    ;; The authentication process is finished.
 388                    (throw 'done t)))
 389                (unless (stringp rsp)
 390                  (apply 'error "Server aborted SASL authentication: %s %s %s"
 391                         rsp))
 392                (sasl-step-set-data step (base64-decode-string rsp))
 393                (setq step (sasl-next-step client step))
 394                (sieve-manage-send
 395                 (if (sasl-step-data step)
 396                     (concat "\""
 397                             (base64-encode-string (sasl-step-data step)
 398                                                   'no-line-break)
 399                             "\"")
 400                   "")))))))
 401       (message "sieve: Authenticating using %s...done" mech)
 402     (message "sieve: Authenticating using %s...failed" mech)))
 403
 404 (defun sieve-manage-cram-md5-p (buffer)
 405   (sieve-manage-capability "SASL" "CRAM-MD5" buffer))
 406
 407 (defun sieve-manage-cram-md5-auth (buffer)
 408   "Login to managesieve server using the CRAM-MD5 SASL method."
 409   (sieve-sasl-auth buffer "CRAM-MD5"))
 410
 411 (defun sieve-manage-digest-md5-p (buffer)
 412   (sieve-manage-capability "SASL" "DIGEST-MD5" buffer))
 413
 414 (defun sieve-manage-digest-md5-auth (buffer)
 415   "Login to managesieve server using the DIGEST-MD5 SASL method."
 416   (sieve-sasl-auth buffer "DIGEST-MD5"))
 417
 418 (defun sieve-manage-scram-md5-p (buffer)
 419   (sieve-manage-capability "SASL" "SCRAM-MD5" buffer))
 420
 421 (defun sieve-manage-scram-md5-auth (buffer)
 422   "Login to managesieve server using the SCRAM-MD5 SASL method."
 423   (sieve-sasl-auth buffer "SCRAM-MD5"))
 424
 425 (defun sieve-manage-ntlm-p (buffer)
 426   (sieve-manage-capability "SASL" "NTLM" buffer))
 427
 428 (defun sieve-manage-ntlm-auth (buffer)
 429   "Login to managesieve server using the NTLM SASL method."
 430   (sieve-sasl-auth buffer "NTLM"))
 431
 432 (defun sieve-manage-plain-p (buffer)
 433   (sieve-manage-capability "SASL" "PLAIN" buffer))
 434
 435 (defun sieve-manage-plain-auth (buffer)
 436   "Login to managesieve server using the PLAIN SASL method."
 437   (sieve-sasl-auth buffer "PLAIN"))
 438
 439 (defun sieve-manage-login-p (buffer)
 440   (sieve-manage-capability "SASL" "LOGIN" buffer))
 441
 442 (defun sieve-manage-login-auth (buffer)
 443   "Login to managesieve server using the LOGIN SASL method."
 444   (sieve-sasl-auth buffer "LOGIN"))
 445
 446 ;; Managesieve API
 447
 448 (defun sieve-manage-open (server &optional port stream auth buffer)
 449   "Open a network connection to a managesieve SERVER (string).
 450 Optional argument PORT is port number (integer) on remote server.
 451 Optional argument STREAM is any of `sieve-manage-streams' (a symbol).
 452 Optional argument AUTH indicates authenticator to use, see
 453 `sieve-manage-authenticators' for available authenticators.
 454 If nil, chooses the best stream the server is capable of.
 455 Optional argument BUFFER is buffer (buffer, or string naming buffer)
 456 to work in."
 457   (setq buffer (or buffer (format " *sieve* %s:%d" server (or port 2000))))
 458   (with-current-buffer (get-buffer-create buffer)
 459     (mapc 'make-local-variable sieve-manage-local-variables)
 460     (sieve-manage-disable-multibyte)
 461     (buffer-disable-undo)
 462     (setq sieve-manage-server (or server sieve-manage-server))
 463     (setq sieve-manage-port (or port sieve-manage-port))
 464     (setq sieve-manage-stream (or stream sieve-manage-stream))
 465     (message "sieve: Connecting to %s..." sieve-manage-server)
 466     (if (let ((sieve-manage-stream
 467                (or sieve-manage-stream sieve-manage-default-stream)))
 468           (sieve-manage-open-1 buffer))
 469         ;; Choose stream.
 470         (let (stream-changed)
 471           (message "sieve: Connecting to %s...done" sieve-manage-server)
 472           (when (null sieve-manage-stream)
 473             (let ((streams sieve-manage-streams))
 474               (while (setq stream (pop streams))
 475                 (if (funcall (nth 1 (assq stream
 476                                           sieve-manage-stream-alist)) buffer)
 477                     (setq stream-changed
 478                           (not (eq (or sieve-manage-stream
 479                                        sieve-manage-default-stream)
 480                                    stream))
 481                           sieve-manage-stream stream
 482                           streams nil)))
 483               (unless sieve-manage-stream
 484                 (error "Couldn't figure out a stream for server"))))
 485           (when stream-changed
 486             (message "sieve: Reconnecting with stream `%s'..."
 487                      sieve-manage-stream)
 488             (sieve-manage-close buffer)
 489             (if (sieve-manage-open-1 buffer)
 490                 (message "sieve: Reconnecting with stream `%s'...done"
 491                          sieve-manage-stream)
 492               (message "sieve: Reconnecting with stream `%s'...failed"
 493                        sieve-manage-stream))
 494             (setq sieve-manage-capability nil))
 495           (if (sieve-manage-opened buffer)
 496               ;; Choose authenticator
 497               (when (and (null sieve-manage-auth)
 498                          (not (eq sieve-manage-state 'auth)))
 499                 (let ((auths sieve-manage-authenticators))
 500                   (while (setq auth (pop auths))
 501                     (if (funcall (nth 1 (assq
 502                                          auth
 503                                          sieve-manage-authenticator-alist))
 504                                  buffer)
 505                         (setq sieve-manage-auth auth
 506                               auths nil)))
 507                   (unless sieve-manage-auth
 508                     (error "Couldn't figure out authenticator for server"))))))
 509       (message "sieve: Connecting to %s...failed" sieve-manage-server))
 510     (when (sieve-manage-opened buffer)
 511       (sieve-manage-erase)
 512       buffer)))
 513
 514 (defun sieve-manage-opened (&optional buffer)
 515   "Return non-nil if connection to managesieve server in BUFFER is open.
 516 If BUFFER is nil then the current buffer is used."
 517   (and (setq buffer (get-buffer (or buffer (current-buffer))))
 518        (buffer-live-p buffer)
 519        (with-current-buffer buffer
 520          (and sieve-manage-process
 521               (memq (process-status sieve-manage-process) '(open run))))))
 522
 523 (defun sieve-manage-close (&optional buffer)
 524   "Close connection to managesieve server in BUFFER.
 525 If BUFFER is nil, the current buffer is used."
 526   (with-current-buffer (or buffer (current-buffer))
 527     (when (sieve-manage-opened)
 528       (sieve-manage-send "LOGOUT")
 529       (sit-for 1))
 530     (when (and sieve-manage-process
 531                (memq (process-status sieve-manage-process) '(open run)))
 532       (delete-process sieve-manage-process))
 533     (setq sieve-manage-process nil)
 534     (sieve-manage-erase)
 535     t))
 536
 537 (defun sieve-manage-authenticate (&optional user passwd buffer)
 538   "Authenticate to server in BUFFER, using current buffer if nil.
 539 It uses the authenticator specified when opening the server.  If the
 540 authenticator requires username/passwords, they are queried from the
 541 user and optionally stored in the buffer.  If USER and/or PASSWD is
 542 specified, the user will not be questioned and the username and/or
 543 password is remembered in the buffer."
 544   (with-current-buffer (or buffer (current-buffer))
 545     (if (not (eq sieve-manage-state 'nonauth))
 546         (eq sieve-manage-state 'auth)
 547       (make-local-variable 'sieve-manage-username)
 548       (make-local-variable 'sieve-manage-password)
 549       (if user (setq sieve-manage-username user))
 550       (if passwd (setq sieve-manage-password passwd))
 551       (if (funcall (nth 2 (assq sieve-manage-auth
 552                                 sieve-manage-authenticator-alist)) buffer)
 553           (setq sieve-manage-state 'auth)))))
 554
 555 (defun sieve-manage-capability (&optional name value buffer)
 556   "Check if capability NAME of server BUFFER match VALUE.
 557 If it does, return the server value of NAME. If not returns nil.
 558 If VALUE is nil, do not check VALUE and return server value.
 559 If NAME is nil, return the full server list of capabilities."
 560   (with-current-buffer (or buffer (current-buffer))
 561     (if (null name)
 562         sieve-manage-capability
 563       (let ((server-value (cadr (assoc name sieve-manage-capability))))
 564         (when (or (null value)
 565                   (and server-value
 566                        (string-match value server-value)))
 567           server-value)))))
 568
 569 (defun sieve-manage-listscripts (&optional buffer)
 570   (with-current-buffer (or buffer (current-buffer))
 571     (sieve-manage-send "LISTSCRIPTS")
 572     (sieve-manage-parse-listscripts)))
 573
 574 (defun sieve-manage-havespace (name size &optional buffer)
 575   (with-current-buffer (or buffer (current-buffer))
 576     (sieve-manage-send (format "HAVESPACE \"%s\" %s" name size))
 577     (sieve-manage-parse-okno)))
 578
 579 (defun sieve-manage-putscript (name content &optional buffer)
 580   (with-current-buffer (or buffer (current-buffer))
 581     (sieve-manage-send (format "PUTSCRIPT \"%s\" {%d+}%s%s" name
 582                                ;; Here we assume that the coding-system will
 583                                ;; replace each char with a single byte.
 584                                ;; This is always the case if `content' is
 585                                ;; a unibyte string.
 586                                (length content)
 587                                sieve-manage-client-eol content))
 588     (sieve-manage-parse-okno)))
 589
 590 (defun sieve-manage-deletescript (name &optional buffer)
 591   (with-current-buffer (or buffer (current-buffer))
 592     (sieve-manage-send (format "DELETESCRIPT \"%s\"" name))
 593     (sieve-manage-parse-okno)))
 594
 595 (defun sieve-manage-getscript (name output-buffer &optional buffer)
 596   (with-current-buffer (or buffer (current-buffer))
 597     (sieve-manage-send (format "GETSCRIPT \"%s\"" name))
 598     (let ((script (sieve-manage-parse-string)))
 599       (sieve-manage-parse-crlf)
 600       (with-current-buffer output-buffer
 601         (insert script))
 602       (sieve-manage-parse-okno))))
 603
 604 (defun sieve-manage-setactive (name &optional buffer)
 605   (with-current-buffer (or buffer (current-buffer))
 606     (sieve-manage-send (format "SETACTIVE \"%s\"" name))
 607     (sieve-manage-parse-okno)))
 608
 609 ;; Protocol parsing routines
 610
 611 (defun sieve-manage-ok-p (rsp)
 612   (string= (downcase (or (car-safe rsp) "")) "ok"))
 613
 614 (defsubst sieve-manage-forward ()
 615   (or (eobp) (forward-char)))
 616
 617 (defun sieve-manage-is-okno ()
 618   (when (looking-at (concat
 619                      "^\\(OK\\|NO\\)\\( (\\([^)]+\\))\\)?\\( \\(.*\\)\\)?"
 620                      sieve-manage-server-eol))
 621     (let ((status (match-string 1))
 622           (resp-code (match-string 3))
 623           (response (match-string 5)))
 624       (when response
 625         (goto-char (match-beginning 5))
 626         (setq response (sieve-manage-is-string)))
 627       (list status resp-code response))))
 628
 629 (defun sieve-manage-parse-okno ()
 630   (let (rsp)
 631     (while (null rsp)
 632       (accept-process-output (get-buffer-process (current-buffer)) 1)
 633       (goto-char (point-min))
 634       (setq rsp (sieve-manage-is-okno)))
 635     (sieve-manage-erase)
 636     rsp))
 637
 638 (defun sieve-manage-parse-capability-1 ()
 639   "Accept a managesieve greeting."
 640   (let (str)
 641     (while (setq str (sieve-manage-is-string))
 642       (if (eq (char-after) ? )
 643           (progn
 644             (sieve-manage-forward)
 645             (push (list str (sieve-manage-is-string))
 646                   sieve-manage-capability))
 647         (push (list str) sieve-manage-capability))
 648       (forward-line)))
 649   (when (re-search-forward (concat "^OK.*" sieve-manage-server-eol) nil t)
 650     (setq sieve-manage-state 'nonauth)))
 651
 652 (defalias 'sieve-manage-parse-greeting-1 'sieve-manage-parse-capability-1)
 653
 654 (defun sieve-manage-is-string ()
 655   (cond ((looking-at "\"\\([^\"]+\\)\"")
 656          (prog1
 657              (match-string 1)
 658            (goto-char (match-end 0))))
 659         ((looking-at (concat "{\\([0-9]+\\+?\\)}" sieve-manage-server-eol))
 660          (let ((pos (match-end 0))
 661                (len (string-to-number (match-string 1))))
 662            (if (< (point-max) (+ pos len))
 663                nil
 664              (goto-char (+ pos len))
 665              (buffer-substring pos (+ pos len)))))))
 666
 667 (defun sieve-manage-parse-string ()
 668   (let (rsp)
 669     (while (null rsp)
 670       (accept-process-output (get-buffer-process (current-buffer)) 1)
 671       (goto-char (point-min))
 672       (setq rsp (sieve-manage-is-string)))
 673     (sieve-manage-erase (point))
 674     rsp))
 675
 676 (defun sieve-manage-parse-crlf ()
 677   (when (looking-at sieve-manage-server-eol)
 678     (sieve-manage-erase (match-end 0))))
 679
 680 (defun sieve-manage-parse-listscripts ()
 681   (let (tmp rsp data)
 682     (while (null rsp)
 683       (while (null (or (setq rsp (sieve-manage-is-okno))
 684                        (setq tmp (sieve-manage-is-string))))
 685         (accept-process-output (get-buffer-process (current-buffer)) 1)
 686         (goto-char (point-min)))
 687       (when tmp
 688         (while (not (looking-at (concat "\\( ACTIVE\\)?"
 689                                         sieve-manage-server-eol)))
 690           (accept-process-output (get-buffer-process (current-buffer)) 1)
 691           (goto-char (point-min)))
 692         (if (match-string 1)
 693             (push (cons 'active tmp) data)
 694           (push tmp data))
 695         (goto-char (match-end 0))
 696         (setq tmp nil)))
 697     (sieve-manage-erase)
 698     (if (sieve-manage-ok-p rsp)
 699         data
 700       rsp)))
 701
 702 (defun sieve-manage-send (cmdstr)
 703   (setq cmdstr (concat cmdstr sieve-manage-client-eol))
 704   (and sieve-manage-log
 705        (with-current-buffer (get-buffer-create sieve-manage-log)
 706          (sieve-manage-disable-multibyte)
 707          (buffer-disable-undo)
 708          (goto-char (point-max))
 709          (insert cmdstr)))
 710   (process-send-string sieve-manage-process cmdstr))
 711
 712 (provide 'sieve-manage)
 713
 714 ;; sieve-manage.el ends here