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