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  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 ;; Internal variables:
 166
 167 (defconst sieve-manage-local-variables '(sieve-manage-server
 168                                          sieve-manage-port
 169                                          sieve-manage-auth
 170                                          sieve-manage-stream
 171                                          sieve-manage-username
 172                                          sieve-manage-password
 173                                          sieve-manage-process
 174                                          sieve-manage-client-eol
 175                                          sieve-manage-server-eol
 176                                          sieve-manage-capability))
 177 (defconst sieve-manage-default-stream 'network)
 178 (defconst sieve-manage-coding-system-for-read 'binary)
 179 (defconst sieve-manage-coding-system-for-write 'binary)
 180 (defvar sieve-manage-stream nil)
 181 (defvar sieve-manage-auth nil)
 182 (defvar sieve-manage-server nil)
 183 (defvar sieve-manage-port nil)
 184 (defvar sieve-manage-username nil)
 185 (defvar sieve-manage-password nil)
 186 (defvar sieve-manage-state 'closed
 187   "Managesieve state.
 188 Valid states are `closed', `initial', `nonauth', and `auth'.")
 189 (defvar sieve-manage-process nil)
 190 (defvar sieve-manage-capability nil)
 191
 192 ;; Internal utility functions
 193
 194 (defsubst sieve-manage-disable-multibyte ()
 195   "Enable multibyte in the current buffer."
 196   (when (fboundp 'set-buffer-multibyte)
 197     (set-buffer-multibyte nil)))
 198
 199 (declare-function password-read         "password-cache" (prompt &optional key))
 200 (declare-function password-cache-add    "password-cache" (key password))
 201 (declare-function password-cache-remove "password-cache" (key))
 202
 203 ;; Uses the dynamically bound `reason' variable.
 204 (defvar reason)
 205 (defun sieve-manage-interactive-login (buffer loginfunc)
 206   "Login to server in BUFFER.
 207 LOGINFUNC is passed a username and a password, it should return t if
 208 it was successful authenticating itself to the server, nil otherwise.
 209 Returns t if login was successful, nil otherwise."
 210   (with-current-buffer buffer
 211     (make-local-variable 'sieve-manage-username)
 212     (make-local-variable 'sieve-manage-password)
 213     (let (user passwd ret reason passwd-key)
 214       (condition-case ()
 215           (while (or (not user) (not passwd))
 216             (setq user (or sieve-manage-username
 217                            (read-from-minibuffer
 218                             (concat "Managesieve username for "
 219                                     sieve-manage-server ": ")
 220                             (or user sieve-manage-default-user)))
 221                   passwd-key (concat "managesieve:" user "@" sieve-manage-server
 222                                      ":" sieve-manage-port)
 223                   passwd (or sieve-manage-password
 224                              (password-read (concat "Managesieve password for "
 225                                                     user "@" sieve-manage-server
 226                                                     ": ")
 227                                             passwd-key)))
 228             (when (y-or-n-p "Store password for this session? ")
 229               (password-cache-add passwd-key (copy-sequence passwd)))
 230             (when (and user passwd)
 231               (if (funcall loginfunc user passwd)
 232                   (setq ret t
 233                         sieve-manage-username user)
 234                 (if reason
 235                     (message "Login failed (reason given: %s)..." reason)
 236                   (message "Login failed..."))
 237                 (password-cache-remove passwd-key)
 238                 (setq sieve-manage-password nil)
 239                 (setq passwd nil)
 240                 (setq reason nil)
 241                 (sit-for 1))))
 242         (quit (with-current-buffer buffer
 243                 (password-cache-remove passwd-key)
 244                 (setq user nil
 245                       passwd nil
 246                       sieve-manage-password nil)))
 247         (error (with-current-buffer buffer
 248                  (password-cache-remove passwd-key)
 249                  (setq user nil
 250                        passwd nil
 251                        sieve-manage-password nil))))
 252       ret)))
 253
 254 (defun sieve-manage-erase (&optional p buffer)
 255   (let ((buffer (or buffer (current-buffer))))
 256     (and sieve-manage-log
 257          (with-current-buffer (get-buffer-create sieve-manage-log)
 258            (sieve-manage-disable-multibyte)
 259            (buffer-disable-undo)
 260            (goto-char (point-max))
 261            (insert-buffer-substring buffer (with-current-buffer buffer
 262                                              (point-min))
 263                                     (or p (with-current-buffer buffer
 264                                             (point-max)))))))
 265   (delete-region (point-min) (or p (point-max))))
 266
 267 (defun sieve-manage-open-1 (buffer)
 268   (with-current-buffer buffer
 269     (sieve-manage-erase)
 270     (setq sieve-manage-state 'initial
 271           sieve-manage-process
 272           (condition-case ()
 273               (funcall (nth 2 (assq sieve-manage-stream
 274                                     sieve-manage-stream-alist))
 275                        "sieve" buffer sieve-manage-server sieve-manage-port)
 276             ((error quit) nil)))
 277     (when sieve-manage-process
 278       (while (and (eq sieve-manage-state 'initial)
 279                   (memq (process-status sieve-manage-process) '(open run)))
 280         (message "Waiting for response from %s..." sieve-manage-server)
 281         (accept-process-output sieve-manage-process 1))
 282       (message "Waiting for response from %s...done" sieve-manage-server)
 283       (and (memq (process-status sieve-manage-process) '(open run))
 284            sieve-manage-process))))
 285
 286 ;; Streams
 287
 288 (defun sieve-manage-network-p (buffer)
 289   t)
 290
 291 (defun sieve-manage-network-open (name buffer server port)
 292   (let* ((port (or port sieve-manage-default-port))
 293          (coding-system-for-read sieve-manage-coding-system-for-read)
 294          (coding-system-for-write sieve-manage-coding-system-for-write)
 295          (process (open-network-stream name buffer server port)))
 296     (when process
 297       (while (and (memq (process-status process) '(open run))
 298                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
 299                   (goto-char (point-min))
 300                   (not (sieve-manage-parse-greeting-1)))
 301         (accept-process-output process 1)
 302         (sit-for 1))
 303       (sieve-manage-erase nil buffer)
 304       (when (memq (process-status process) '(open run))
 305         process))))
 306
 307 (defun imap-starttls-p (buffer)
 308   ;;  (and (imap-capability 'STARTTLS buffer)
 309   (condition-case ()
 310       (progn
 311         (require 'starttls)
 312         (call-process "starttls"))
 313     (error nil)))
 314
 315 (defun imap-starttls-open (name buffer server port)
 316   (let* ((port (or port sieve-manage-default-port))
 317          (coding-system-for-read sieve-manage-coding-system-for-read)
 318          (coding-system-for-write sieve-manage-coding-system-for-write)
 319          (process (starttls-open-stream name buffer server port))
 320          done)
 321     (when process
 322       (while (and (memq (process-status process) '(open run))
 323                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
 324                   (goto-char (point-min))
 325                   (not (sieve-manage-parse-greeting-1)))
 326         (accept-process-output process 1)
 327         (sit-for 1))
 328       (sieve-manage-erase nil buffer)
 329       (sieve-manage-send "STARTTLS")
 330       (starttls-negotiate process))
 331     (when (memq (process-status process) '(open run))
 332       process)))
 333
 334 ;; Authenticators
 335
 336 (defun sieve-sasl-auth (buffer mech)
 337   "Login to server using the SASL MECH method."
 338   (message "sieve: Authenticating using %s..." mech)
 339   (if (sieve-manage-interactive-login
 340        buffer
 341        (lambda (user passwd)
 342          (let (client step tag data rsp)
 343            (setq client (sasl-make-client (sasl-find-mechanism (list mech))
 344                                           user "sieve" sieve-manage-server))
 345            (setq sasl-read-passphrase (function (lambda (prompt) passwd)))
 346            (setq step (sasl-next-step client nil))
 347            (setq tag
 348                  (sieve-manage-send
 349                   (concat
 350                    "AUTHENTICATE \""
 351                    mech
 352                    "\""
 353                    (and (sasl-step-data step)
 354                         (concat
 355                          " \""
 356                          (base64-encode-string
 357                           (sasl-step-data step)
 358                           'no-line-break)
 359                          "\"")))))
 360            (catch 'done
 361              (while t
 362                (setq rsp nil)
 363                (goto-char (point-min))
 364                (while (null (or (progn
 365                                   (setq rsp (sieve-manage-is-string))
 366                                   (if (not (and rsp (looking-at
 367                                                      sieve-manage-server-eol)))
 368                                       (setq rsp nil)
 369                                     (goto-char (match-end 0))
 370                                     rsp))
 371                                 (setq rsp (sieve-manage-is-okno))))
 372                  (accept-process-output sieve-manage-process 1)
 373                  (goto-char (point-min)))
 374                (sieve-manage-erase)
 375                (when (sieve-manage-ok-p rsp)
 376                  (when (string-match "^SASL \"\\([^\"]+\\)\"" (cadr rsp))
 377                    (sasl-step-set-data
 378                     step (base64-decode-string (match-string 1 (cadr rsp)))))
 379                  (if (and (setq step (sasl-next-step client step))
 380                           (setq data (sasl-step-data step)))
 381                      ;; We got data for server but it's finished
 382                      (error "Server not ready for SASL data: %s" data)
 383                    ;; The authentication process is finished.
 384                    (throw 'done t)))
 385                (unless (stringp rsp)
 386                  (apply 'error "Server aborted SASL authentication: %s %s %s"
 387                         rsp))
 388                (sasl-step-set-data step (base64-decode-string rsp))
 389                (setq step (sasl-next-step client step))
 390                (sieve-manage-send
 391                 (if (sasl-step-data step)
 392                     (concat "\""
 393                             (base64-encode-string (sasl-step-data step)
 394                                                   'no-line-break)
 395                             "\"")
 396                   "")))))))
 397       (message "sieve: Authenticating using %s...done" mech)
 398     (message "sieve: Authenticating using %s...failed" mech)))
 399
 400 (defun sieve-manage-cram-md5-p (buffer)
 401   (sieve-manage-capability "SASL" "CRAM-MD5" buffer))
 402
 403 (defun sieve-manage-cram-md5-auth (buffer)
 404   "Login to managesieve server using the CRAM-MD5 SASL method."
 405   (sieve-sasl-auth buffer "CRAM-MD5"))
 406
 407 (defun sieve-manage-digest-md5-p (buffer)
 408   (sieve-manage-capability "SASL" "DIGEST-MD5" buffer))
 409
 410 (defun sieve-manage-digest-md5-auth (buffer)
 411   "Login to managesieve server using the DIGEST-MD5 SASL method."
 412   (sieve-sasl-auth buffer "DIGEST-MD5"))
 413
 414 (defun sieve-manage-scram-md5-p (buffer)
 415   (sieve-manage-capability "SASL" "SCRAM-MD5" buffer))
 416
 417 (defun sieve-manage-scram-md5-auth (buffer)
 418   "Login to managesieve server using the SCRAM-MD5 SASL method."
 419   (sieve-sasl-auth buffer "SCRAM-MD5"))
 420
 421 (defun sieve-manage-ntlm-p (buffer)
 422   (sieve-manage-capability "SASL" "NTLM" buffer))
 423
 424 (defun sieve-manage-ntlm-auth (buffer)
 425   "Login to managesieve server using the NTLM SASL method."
 426   (sieve-sasl-auth buffer "NTLM"))
 427
 428 (defun sieve-manage-plain-p (buffer)
 429   (sieve-manage-capability "SASL" "PLAIN" buffer))
 430
 431 (defun sieve-manage-plain-auth (buffer)
 432   "Login to managesieve server using the PLAIN SASL method."
 433   (sieve-sasl-auth buffer "PLAIN"))
 434
 435 (defun sieve-manage-login-p (buffer)
 436   (sieve-manage-capability "SASL" "LOGIN" buffer))
 437
 438 (defun sieve-manage-login-auth (buffer)
 439   "Login to managesieve server using the LOGIN SASL method."
 440   (sieve-sasl-auth buffer "LOGIN"))
 441
 442 ;; Managesieve API
 443
 444 (defun sieve-manage-open (server &optional port stream auth buffer)
 445   "Open a network connection to a managesieve SERVER (string).
 446 Optional variable PORT is port number (integer) on remote server.
 447 Optional variable STREAM is any of `sieve-manage-streams' (a symbol).
 448 Optional variable AUTH indicates authenticator to use, see
 449 `sieve-manage-authenticators' for available authenticators.  If nil, chooses
 450 the best stream the server is capable of.
 451 Optional variable BUFFER is buffer (buffer, or string naming buffer)
 452 to work in."
 453   (setq buffer (or buffer (format " *sieve* %s:%d" server (or port 2000))))
 454   (with-current-buffer (get-buffer-create buffer)
 455     (mapc 'make-local-variable sieve-manage-local-variables)
 456     (sieve-manage-disable-multibyte)
 457     (buffer-disable-undo)
 458     (setq sieve-manage-server (or server sieve-manage-server))
 459     (setq sieve-manage-port (or port sieve-manage-port))
 460     (setq sieve-manage-stream (or stream sieve-manage-stream))
 461     (message "sieve: Connecting to %s..." sieve-manage-server)
 462     (if (let ((sieve-manage-stream
 463                (or sieve-manage-stream sieve-manage-default-stream)))
 464           (sieve-manage-open-1 buffer))
 465         ;; Choose stream.
 466         (let (stream-changed)
 467           (message "sieve: Connecting to %s...done" sieve-manage-server)
 468           (when (null sieve-manage-stream)
 469             (let ((streams sieve-manage-streams))
 470               (while (setq stream (pop streams))
 471                 (if (funcall (nth 1 (assq stream
 472                                           sieve-manage-stream-alist)) buffer)
 473                     (setq stream-changed
 474                           (not (eq (or sieve-manage-stream
 475                                        sieve-manage-default-stream)
 476                                    stream))
 477                           sieve-manage-stream stream
 478                           streams nil)))
 479               (unless sieve-manage-stream
 480                 (error "Couldn't figure out a stream for server"))))
 481           (when stream-changed
 482             (message "sieve: Reconnecting with stream `%s'..."
 483                      sieve-manage-stream)
 484             (sieve-manage-close buffer)
 485             (if (sieve-manage-open-1 buffer)
 486                 (message "sieve: Reconnecting with stream `%s'...done"
 487                          sieve-manage-stream)
 488               (message "sieve: Reconnecting with stream `%s'...failed"
 489                        sieve-manage-stream))
 490             (setq sieve-manage-capability nil))
 491           (if (sieve-manage-opened buffer)
 492               ;; Choose authenticator
 493               (when (and (null sieve-manage-auth)
 494                          (not (eq sieve-manage-state 'auth)))
 495                 (let ((auths sieve-manage-authenticators))
 496                   (while (setq auth (pop auths))
 497                     (if (funcall (nth 1 (assq
 498                                          auth
 499                                          sieve-manage-authenticator-alist))
 500                                  buffer)
 501                         (setq sieve-manage-auth auth
 502                               auths nil)))
 503                   (unless sieve-manage-auth
 504                     (error "Couldn't figure out authenticator for server"))))))
 505       (message "sieve: Connecting to %s...failed" sieve-manage-server))
 506     (when (sieve-manage-opened buffer)
 507       (sieve-manage-erase)
 508       buffer)))
 509
 510 (defun sieve-manage-opened (&optional buffer)
 511   "Return non-nil if connection to managesieve server in BUFFER is open.
 512 If BUFFER is nil then the current buffer is used."
 513   (and (setq buffer (get-buffer (or buffer (current-buffer))))
 514        (buffer-live-p buffer)
 515        (with-current-buffer buffer
 516          (and sieve-manage-process
 517               (memq (process-status sieve-manage-process) '(open run))))))
 518
 519 (defun sieve-manage-close (&optional buffer)
 520   "Close connection to managesieve server in BUFFER.
 521 If BUFFER is nil, the current buffer is used."
 522   (with-current-buffer (or buffer (current-buffer))
 523     (when (sieve-manage-opened)
 524       (sieve-manage-send "LOGOUT")
 525       (sit-for 1))
 526     (when (and sieve-manage-process
 527                (memq (process-status sieve-manage-process) '(open run)))
 528       (delete-process sieve-manage-process))
 529     (setq sieve-manage-process nil)
 530     (sieve-manage-erase)
 531     t))
 532
 533 (defun sieve-manage-authenticate (&optional user passwd buffer)
 534   "Authenticate to server in BUFFER, using current buffer if nil.
 535 It uses the authenticator specified when opening the server.  If the
 536 authenticator requires username/passwords, they are queried from the
 537 user and optionally stored in the buffer.  If USER and/or PASSWD is
 538 specified, the user will not be questioned and the username and/or
 539 password is remembered in the buffer."
 540   (with-current-buffer (or buffer (current-buffer))
 541     (if (not (eq sieve-manage-state 'nonauth))
 542         (eq sieve-manage-state 'auth)
 543       (make-local-variable 'sieve-manage-username)
 544       (make-local-variable 'sieve-manage-password)
 545       (if user (setq sieve-manage-username user))
 546       (if passwd (setq sieve-manage-password passwd))
 547       (if (funcall (nth 2 (assq sieve-manage-auth
 548                                 sieve-manage-authenticator-alist)) buffer)
 549           (setq sieve-manage-state 'auth)))))
 550
 551 (defun sieve-manage-capability (&optional name value buffer)
 552   (with-current-buffer (or buffer (current-buffer))
 553     (if (null name)
 554         sieve-manage-capability
 555       (if (null value)
 556           (nth 1 (assoc name sieve-manage-capability))
 557         (when (string-match value (nth 1 (assoc name sieve-manage-capability)))
 558           (nth 1 (assoc name sieve-manage-capability)))))))
 559
 560 (defun sieve-manage-listscripts (&optional buffer)
 561   (with-current-buffer (or buffer (current-buffer))
 562     (sieve-manage-send "LISTSCRIPTS")
 563     (sieve-manage-parse-listscripts)))
 564
 565 (defun sieve-manage-havespace (name size &optional buffer)
 566   (with-current-buffer (or buffer (current-buffer))
 567     (sieve-manage-send (format "HAVESPACE \"%s\" %s" name size))
 568     (sieve-manage-parse-okno)))
 569
 570 (defun sieve-manage-putscript (name content &optional buffer)
 571   (with-current-buffer (or buffer (current-buffer))
 572     (sieve-manage-send (format "PUTSCRIPT \"%s\" {%d+}%s%s" name
 573                                ;; Here we assume that the coding-system will
 574                                ;; replace each char with a single byte.
 575                                ;; This is always the case if `content' is
 576                                ;; a unibyte string.
 577                                (length content)
 578                                sieve-manage-client-eol content))
 579     (sieve-manage-parse-okno)))
 580
 581 (defun sieve-manage-deletescript (name &optional buffer)
 582   (with-current-buffer (or buffer (current-buffer))
 583     (sieve-manage-send (format "DELETESCRIPT \"%s\"" name))
 584     (sieve-manage-parse-okno)))
 585
 586 (defun sieve-manage-getscript (name output-buffer &optional buffer)
 587   (with-current-buffer (or buffer (current-buffer))
 588     (sieve-manage-send (format "GETSCRIPT \"%s\"" name))
 589     (let ((script (sieve-manage-parse-string)))
 590       (sieve-manage-parse-crlf)
 591       (with-current-buffer output-buffer
 592         (insert script))
 593       (sieve-manage-parse-okno))))
 594
 595 (defun sieve-manage-setactive (name &optional buffer)
 596   (with-current-buffer (or buffer (current-buffer))
 597     (sieve-manage-send (format "SETACTIVE \"%s\"" name))
 598     (sieve-manage-parse-okno)))
 599
 600 ;; Protocol parsing routines
 601
 602 (defun sieve-manage-ok-p (rsp)
 603   (string= (downcase (or (car-safe rsp) "")) "ok"))
 604
 605 (defsubst sieve-manage-forward ()
 606   (or (eobp) (forward-char)))
 607
 608 (defun sieve-manage-is-okno ()
 609   (when (looking-at (concat
 610                      "^\\(OK\\|NO\\)\\( (\\([^)]+\\))\\)?\\( \\(.*\\)\\)?"
 611                      sieve-manage-server-eol))
 612     (let ((status (match-string 1))
 613           (resp-code (match-string 3))
 614           (response (match-string 5)))
 615       (when response
 616         (goto-char (match-beginning 5))
 617         (setq response (sieve-manage-is-string)))
 618       (list status resp-code response))))
 619
 620 (defun sieve-manage-parse-okno ()
 621   (let (rsp)
 622     (while (null rsp)
 623       (accept-process-output (get-buffer-process (current-buffer)) 1)
 624       (goto-char (point-min))
 625       (setq rsp (sieve-manage-is-okno)))
 626     (sieve-manage-erase)
 627     rsp))
 628
 629 (defun sieve-manage-parse-capability-1 ()
 630   "Accept a managesieve greeting."
 631   (let (str)
 632     (while (setq str (sieve-manage-is-string))
 633       (if (eq (char-after) ? )
 634           (progn
 635             (sieve-manage-forward)
 636             (push (list str (sieve-manage-is-string))
 637                   sieve-manage-capability))
 638         (push (list str) sieve-manage-capability))
 639       (forward-line)))
 640   (when (re-search-forward (concat "^OK" sieve-manage-server-eol) nil t)
 641     (setq sieve-manage-state 'nonauth)))
 642
 643 (defalias 'sieve-manage-parse-greeting-1 'sieve-manage-parse-capability-1)
 644
 645 (defun sieve-manage-is-string ()
 646   (cond ((looking-at "\"\\([^\"]+\\)\"")
 647          (prog1
 648              (match-string 1)
 649            (goto-char (match-end 0))))
 650         ((looking-at (concat "{\\([0-9]+\\)}" sieve-manage-server-eol))
 651          (let ((pos (match-end 0))
 652                (len (string-to-number (match-string 1))))
 653            (if (< (point-max) (+ pos len))
 654                nil
 655              (goto-char (+ pos len))
 656              (buffer-substring pos (+ pos len)))))))
 657
 658 (defun sieve-manage-parse-string ()
 659   (let (rsp)
 660     (while (null rsp)
 661       (accept-process-output (get-buffer-process (current-buffer)) 1)
 662       (goto-char (point-min))
 663       (setq rsp (sieve-manage-is-string)))
 664     (sieve-manage-erase (point))
 665     rsp))
 666
 667 (defun sieve-manage-parse-crlf ()
 668   (when (looking-at sieve-manage-server-eol)
 669     (sieve-manage-erase (match-end 0))))
 670
 671 (defun sieve-manage-parse-listscripts ()
 672   (let (tmp rsp data)
 673     (while (null rsp)
 674       (while (null (or (setq rsp (sieve-manage-is-okno))
 675                        (setq tmp (sieve-manage-is-string))))
 676         (accept-process-output (get-buffer-process (current-buffer)) 1)
 677         (goto-char (point-min)))
 678       (when tmp
 679         (while (not (looking-at (concat "\\( ACTIVE\\)?"
 680                                         sieve-manage-server-eol)))
 681           (accept-process-output (get-buffer-process (current-buffer)) 1)
 682           (goto-char (point-min)))
 683         (if (match-string 1)
 684             (push (cons 'active tmp) data)
 685           (push tmp data))
 686         (goto-char (match-end 0))
 687         (setq tmp nil)))
 688     (sieve-manage-erase)
 689     (if (sieve-manage-ok-p rsp)
 690         data
 691       rsp)))
 692
 693 (defun sieve-manage-send (cmdstr)
 694   (setq cmdstr (concat cmdstr sieve-manage-client-eol))
 695   (and sieve-manage-log
 696        (with-current-buffer (get-buffer-create sieve-manage-log)
 697          (sieve-manage-disable-multibyte)
 698          (buffer-disable-undo)
 699          (goto-char (point-max))
 700          (insert cmdstr)))
 701   (process-send-string sieve-manage-process cmdstr))
 702
 703 (provide 'sieve-manage)
 704
 705 ;; arch-tag: 321c4640-1371-4495-9baf-8ccb71dd5bd1
 706 ;; sieve-manage.el ends here