git.chise.org Git - elisp/gnus.git-/blob - lisp/sieve-manage.el

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