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