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

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