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