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