Fix build for (S)XEmacs.
[gnus] / lisp / imap.el
1 ;;; imap.el --- imap library
2
3 ;; Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 ;;   2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6 ;; Author: Simon Josefsson <simon@josefsson.org>
7 ;; Keywords: mail
8
9 ;; This file is part of GNU Emacs.
10
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
15
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 ;; GNU General Public License for more details.
20
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
23
24 ;;; Commentary:
25
26 ;; imap.el is an elisp library providing an interface for talking to
27 ;; IMAP servers.
28 ;;
29 ;; imap.el is roughly divided in two parts, one that parses IMAP
30 ;; responses from the server and storing data into buffer-local
31 ;; variables, and one for utility functions which send commands to
32 ;; server, waits for an answer, and return information.  The latter
33 ;; part is layered on top of the previous.
34 ;;
35 ;; The imap.el API consist of the following functions, other functions
36 ;; in this file should not be called directly and the result of doing
37 ;; so are at best undefined.
38 ;;
39 ;; Global commands:
40 ;;
41 ;; imap-open,       imap-opened,    imap-authenticate, imap-close,
42 ;; imap-capability, imap-namespace, imap-error-text
43 ;;
44 ;; Mailbox commands:
45 ;;
46 ;; imap-mailbox-get,       imap-mailbox-map,         imap-current-mailbox,
47 ;; imap-current-mailbox-p, imap-search,              imap-mailbox-select,
48 ;; imap-mailbox-examine,   imap-mailbox-unselect,    imap-mailbox-expunge
49 ;; imap-mailbox-close,     imap-mailbox-create,      imap-mailbox-delete
50 ;; imap-mailbox-rename,    imap-mailbox-lsub,        imap-mailbox-list
51 ;; imap-mailbox-subscribe, imap-mailbox-unsubscribe, imap-mailbox-status
52 ;; imap-mailbox-acl-get,   imap-mailbox-acl-set,     imap-mailbox-acl-delete
53 ;;
54 ;; Message commands:
55 ;;
56 ;; imap-fetch-asynch,                 imap-fetch,
57 ;; imap-current-message,              imap-list-to-message-set,
58 ;; imap-message-get,                  imap-message-map
59 ;; imap-message-envelope-date,        imap-message-envelope-subject,
60 ;; imap-message-envelope-from,        imap-message-envelope-sender,
61 ;; imap-message-envelope-reply-to,    imap-message-envelope-to,
62 ;; imap-message-envelope-cc,          imap-message-envelope-bcc
63 ;; imap-message-envelope-in-reply-to, imap-message-envelope-message-id
64 ;; imap-message-body,                 imap-message-flag-permanent-p
65 ;; imap-message-flags-set,            imap-message-flags-del
66 ;; imap-message-flags-add,            imap-message-copyuid
67 ;; imap-message-copy,                 imap-message-appenduid
68 ;; imap-message-append,               imap-envelope-from
69 ;; imap-body-lines
70 ;;
71 ;; It is my hope that these commands should be pretty self
72 ;; explanatory for someone that know IMAP.  All functions have
73 ;; additional documentation on how to invoke them.
74 ;;
75 ;; imap.el supports RFC1730/2060/RFC3501 (IMAP4/IMAP4rev1).  The implemented
76 ;; IMAP extensions are RFC2195 (CRAM-MD5), RFC2086 (ACL), RFC2342
77 ;; (NAMESPACE), RFC2359 (UIDPLUS), the IMAP-part of RFC2595 (STARTTLS,
78 ;; LOGINDISABLED) (with use of external library starttls.el and
79 ;; program starttls), and the GSSAPI / Kerberos V4 sections of RFC1731
80 ;; (with use of external program `imtest'), and RFC2971 (ID).  It also
81 ;; takes advantage of the UNSELECT extension in Cyrus IMAPD.
82 ;;
83 ;; Without the work of John McClary Prevost and Jim Radford this library
84 ;; would not have seen the light of day.  Many thanks.
85 ;;
86 ;; This is a transcript of a short interactive session for demonstration
87 ;; purposes.
88 ;;
89 ;; (imap-open "my.mail.server")
90 ;; => " *imap* my.mail.server:0"
91 ;;
92 ;; The rest are invoked with current buffer as the buffer returned by
93 ;; `imap-open'.  It is possible to do it all without this, but it would
94 ;; look ugly here since `buffer' is always the last argument for all
95 ;; imap.el API functions.
96 ;;
97 ;; (imap-authenticate "myusername" "mypassword")
98 ;; => auth
99 ;;
100 ;; (imap-mailbox-lsub "*")
101 ;; => ("INBOX.sentmail" "INBOX.private" "INBOX.draft" "INBOX.spam")
102 ;;
103 ;; (imap-mailbox-list "INBOX.n%")
104 ;; => ("INBOX.namedroppers" "INBOX.nnimap" "INBOX.ntbugtraq")
105 ;;
106 ;; (imap-mailbox-select "INBOX.nnimap")
107 ;; => "INBOX.nnimap"
108 ;;
109 ;; (imap-mailbox-get 'exists)
110 ;; => 166
111 ;;
112 ;; (imap-mailbox-get 'uidvalidity)
113 ;; => "908992622"
114 ;;
115 ;; (imap-search "FLAGGED SINCE 18-DEC-98")
116 ;; => (235 236)
117 ;;
118 ;; (imap-fetch 235 "RFC822.PEEK" 'RFC822)
119 ;; => "X-Sieve: cmu-sieve 1.3^M\nX-Username: <jas@pdc.kth.se>^M\r...."
120 ;;
121 ;; Todo:
122 ;;
123 ;; o Parse UIDs as strings? We need to overcome the 28 bit limit somehow.
124 ;;   Use IEEE floats (which are effectively exact)?  -- fx
125 ;; o Don't use `read' at all (important places already fixed)
126 ;; o Accept list of articles instead of message set string in most
127 ;;   imap-message-* functions.
128 ;; o Send strings as literal if they contain, e.g., ".
129 ;;
130 ;; Revision history:
131 ;;
132 ;;  - 19991218 added starttls/digest-md5 patch,
133 ;;             by Daiki Ueno <ueno@ueda.info.waseda.ac.jp>
134 ;;             NB! you need SLIM for starttls.el and digest-md5.el
135 ;;  - 19991023 committed to pgnus
136 ;;
137
138 ;;; Code:
139
140 (eval-when-compile (require 'cl))
141 (eval-and-compile
142   (unless (fboundp 'declare-function) (defmacro declare-function (&rest r)))
143   (autoload 'starttls-open-stream "starttls")
144   (autoload 'starttls-negotiate "starttls")
145   (autoload 'sasl-find-mechanism "sasl")
146   (autoload 'digest-md5-parse-digest-challenge "digest-md5")
147   (autoload 'digest-md5-digest-response "digest-md5")
148   (autoload 'digest-md5-digest-uri "digest-md5")
149   (autoload 'digest-md5-challenge "digest-md5")
150   (autoload 'rfc2104-hash "rfc2104")
151   (autoload 'utf7-encode "utf7")
152   (autoload 'utf7-decode "utf7")
153   (autoload 'format-spec "format-spec")
154   (autoload 'format-spec-make "format-spec")
155   (autoload 'open-tls-stream "tls"))
156
157 ;; User variables.
158
159 (defgroup imap nil
160   "Low-level IMAP issues."
161   :version "21.1"
162   :group 'mail)
163
164 (defcustom imap-kerberos4-program '("imtest -m kerberos_v4 -u %l -p %p %s"
165                                     "imtest -kp %s %p")
166   "List of strings containing commands for Kerberos 4 authentication.
167 %s is replaced with server hostname, %p with port to connect to, and
168 %l with the value of `imap-default-user'.  The program should accept
169 IMAP commands on stdin and return responses to stdout.  Each entry in
170 the list is tried until a successful connection is made."
171   :group 'imap
172   :type '(repeat string))
173
174 (defcustom imap-gssapi-program (list
175                                 (concat "gsasl %s %p "
176                                         "--mechanism GSSAPI "
177                                         "--authentication-id %l")
178                                 "imtest -m gssapi -u %l -p %p %s")
179   "List of strings containing commands for GSSAPI (krb5) authentication.
180 %s is replaced with server hostname, %p with port to connect to, and
181 %l with the value of `imap-default-user'.  The program should accept
182 IMAP commands on stdin and return responses to stdout.  Each entry in
183 the list is tried until a successful connection is made."
184   :group 'imap
185   :type '(repeat string))
186
187 (defcustom imap-ssl-program '("openssl s_client -quiet -ssl3 -connect %s:%p"
188                               "openssl s_client -quiet -ssl2 -connect %s:%p"
189                               "s_client -quiet -ssl3 -connect %s:%p"
190                               "s_client -quiet -ssl2 -connect %s:%p")
191   "A string, or list of strings, containing commands for SSL connections.
192 Within a string, %s is replaced with the server address and %p with
193 port number on server.  The program should accept IMAP commands on
194 stdin and return responses to stdout.  Each entry in the list is tried
195 until a successful connection is made."
196   :group 'imap
197   :type '(choice string
198                  (repeat string)))
199
200 (defcustom imap-shell-program '("ssh %s imapd"
201                                 "rsh %s imapd"
202                                 "ssh %g ssh %s imapd"
203                                 "rsh %g rsh %s imapd")
204   "A list of strings, containing commands for IMAP connection.
205 Within a string, %s is replaced with the server address, %p with port
206 number on server, %g with `imap-shell-host', and %l with
207 `imap-default-user'.  The program should read IMAP commands from stdin
208 and write IMAP response to stdout.  Each entry in the list is tried
209 until a successful connection is made."
210   :group 'imap
211   :type '(repeat string))
212
213 (defcustom imap-process-connection-type nil
214   "*Value for `process-connection-type' to use for Kerberos4, GSSAPI and SSL.
215 The `process-connection-type' variable controls the type of device
216 used to communicate with subprocesses.  Values are nil to use a
217 pipe, or t or `pty' to use a pty.  The value has no effect if the
218 system has no ptys or if all ptys are busy: then a pipe is used
219 in any case.  The value takes effect when an IMAP server is
220 opened; changing it after that has no effect."
221   :version "22.1"
222   :group 'imap
223   :type 'boolean)
224
225 (defcustom imap-use-utf7 t
226   "If non-nil, do utf7 encoding/decoding of mailbox names.
227 Since the UTF7 decoding currently only decodes into ISO-8859-1
228 characters, you may disable this decoding if you need to access UTF7
229 encoded mailboxes which doesn't translate into ISO-8859-1."
230   :group 'imap
231   :type 'boolean)
232
233 (defcustom imap-log nil
234   "If non-nil, an imap session trace is placed in `imap-log-buffer'.
235 Note that username, passwords and other privacy sensitive
236 information (such as e-mail) may be stored in the buffer.
237 It is not written to disk, however.  Do not enable this
238 variable unless you are comfortable with that.
239
240 See also `imap-debug'."
241   :group 'imap
242   :type 'boolean)
243
244 (defcustom imap-debug nil
245   "If non-nil, trace imap- functions into `imap-debug-buffer'.
246 Uses `trace-function-background', so you can turn it off with,
247 say, `untrace-all'.
248
249 Note that username, passwords and other privacy sensitive
250 information (such as e-mail) may be stored in the buffer.
251 It is not written to disk, however.  Do not enable this
252 variable unless you are comfortable with that.
253
254 This variable only takes effect when loading the `imap' library.
255 See also `imap-log'."
256   :group 'imap
257   :type 'boolean)
258
259 (defcustom imap-shell-host "gateway"
260   "Hostname of rlogin proxy."
261   :group 'imap
262   :type 'string)
263
264 (defcustom imap-default-user (user-login-name)
265   "Default username to use."
266   :group 'imap
267   :type 'string)
268
269 (defcustom imap-read-timeout (if (string-match
270                                   "windows-nt\\|os/2\\|emx\\|cygwin"
271                                   (symbol-name system-type))
272                                  1.0
273                                0.1)
274   "*How long to wait between checking for the end of output.
275 Shorter values mean quicker response, but is more CPU intensive."
276   :type 'number
277   :group 'imap)
278
279 (defcustom imap-store-password nil
280   "If non-nil, store session password without prompting."
281   :group 'imap
282   :type 'boolean)
283
284 ;; Various variables.
285
286 (defvar imap-fetch-data-hook nil
287   "Hooks called after receiving each FETCH response.")
288
289 (defvar imap-streams '(gssapi kerberos4 starttls tls ssl network shell)
290   "Priority of streams to consider when opening connection to server.")
291
292 (defvar imap-stream-alist
293   '((gssapi    imap-gssapi-stream-p    imap-gssapi-open)
294     (kerberos4 imap-kerberos4-stream-p imap-kerberos4-open)
295     (tls       imap-tls-p              imap-tls-open)
296     (ssl       imap-ssl-p              imap-ssl-open)
297     (network   imap-network-p          imap-network-open)
298     (shell     imap-shell-p            imap-shell-open)
299     (starttls  imap-starttls-p         imap-starttls-open))
300   "Definition of network streams.
301
302 \(NAME CHECK OPEN)
303
304 NAME names the stream, CHECK is a function returning non-nil if the
305 server support the stream and OPEN is a function for opening the
306 stream.")
307
308 (defvar imap-authenticators '(gssapi
309                               kerberos4
310                               digest-md5
311                               cram-md5
312                               ;;sasl
313                               login
314                               anonymous)
315   "Priority of authenticators to consider when authenticating to server.")
316
317 (defvar imap-authenticator-alist
318   '((gssapi     imap-gssapi-auth-p    imap-gssapi-auth)
319     (kerberos4  imap-kerberos4-auth-p imap-kerberos4-auth)
320     (sasl       imap-sasl-auth-p      imap-sasl-auth)
321     (cram-md5   imap-cram-md5-p       imap-cram-md5-auth)
322     (login      imap-login-p          imap-login-auth)
323     (anonymous  imap-anonymous-p      imap-anonymous-auth)
324     (digest-md5 imap-digest-md5-p     imap-digest-md5-auth))
325   "Definition of authenticators.
326
327 \(NAME CHECK AUTHENTICATE)
328
329 NAME names the authenticator.  CHECK is a function returning non-nil if
330 the server support the authenticator and AUTHENTICATE is a function
331 for doing the actual authentication.")
332
333 (defvar imap-error nil
334   "Error codes from the last command.")
335
336 (defvar imap-logout-timeout nil
337   "Close server immediately if it can't logout in this number of seconds.
338 If it is nil, never close server until logout completes.  Normally,
339 the value of this variable will be bound to a certain value to which
340 an application program that uses this module specifies on a per-server
341 basis.")
342
343 ;; Internal constants.  Change these and die.
344
345 (defconst imap-default-port 143)
346 (defconst imap-default-ssl-port 993)
347 (defconst imap-default-tls-port 993)
348 (defconst imap-default-stream 'network)
349 (defconst imap-coding-system-for-read 'binary)
350 (defconst imap-coding-system-for-write 'binary)
351 (defconst imap-local-variables '(imap-server
352                                  imap-port
353                                  imap-client-eol
354                                  imap-server-eol
355                                  imap-auth
356                                  imap-stream
357                                  imap-username
358                                  imap-password
359                                  imap-current-mailbox
360                                  imap-current-target-mailbox
361                                  imap-message-data
362                                  imap-capability
363                                  imap-id
364                                  imap-namespace
365                                  imap-state
366                                  imap-reached-tag
367                                  imap-failed-tags
368                                  imap-tag
369                                  imap-process
370                                  imap-calculate-literal-size-first
371                                  imap-mailbox-data))
372 (defconst imap-log-buffer "*imap-log*")
373 (defconst imap-debug-buffer "*imap-debug*")
374
375 ;; Internal variables.
376
377 (defvar imap-stream nil)
378 (defvar imap-auth nil)
379 (defvar imap-server nil)
380 (defvar imap-port nil)
381 (defvar imap-username nil)
382 (defvar imap-password nil)
383 (defvar imap-last-authenticator nil)
384 (defvar imap-calculate-literal-size-first nil)
385 (defvar imap-state 'closed
386   "IMAP state.
387 Valid states are `closed', `initial', `nonauth', `auth', `selected'
388 and `examine'.")
389
390 (defvar imap-server-eol "\r\n"
391   "The EOL string sent from the server.")
392
393 (defvar imap-client-eol "\r\n"
394   "The EOL string we send to the server.")
395
396 (defvar imap-current-mailbox nil
397   "Current mailbox name.")
398
399 (defvar imap-current-target-mailbox nil
400   "Current target mailbox for COPY and APPEND commands.")
401
402 (defvar imap-mailbox-data nil
403   "Obarray with mailbox data.")
404
405 (defvar imap-mailbox-prime 997
406   "Length of `imap-mailbox-data'.")
407
408 (defvar imap-current-message nil
409   "Current message number.")
410
411 (defvar imap-message-data nil
412   "Obarray with message data.")
413
414 (defvar imap-message-prime 997
415   "Length of `imap-message-data'.")
416
417 (defvar imap-capability nil
418   "Capability for server.")
419
420 (defvar imap-id nil
421   "Identity of server.
422 See RFC 2971.")
423
424 (defvar imap-namespace nil
425   "Namespace for current server.")
426
427 (defvar imap-reached-tag 0
428   "Lower limit on command tags that have been parsed.")
429
430 (defvar imap-failed-tags nil
431   "Alist of tags that failed.
432 Each element is a list with four elements; tag (a integer), response
433 state (a symbol, `OK', `NO' or `BAD'), response code (a string), and
434 human readable response text (a string).")
435
436 (defvar imap-tag 0
437   "Command tag number.")
438
439 (defvar imap-process nil
440   "Process.")
441
442 (defvar imap-continuation nil
443   "Non-nil indicates that the server emitted a continuation request.
444 The actual value is really the text on the continuation line.")
445
446 (defvar imap-callbacks nil
447   "List of response tags and callbacks, on the form `(number . function)'.
448 The function should take two arguments, the first the IMAP tag and the
449 second the status (OK, NO, BAD etc) of the command.")
450
451 (defvar imap-enable-exchange-bug-workaround nil
452   "Send FETCH UID commands as *:* instead of *.
453
454 When non-nil, use an alternative UIDS form.  Enabling appears to
455 be required for some servers (e.g., Microsoft Exchange 2007)
456 which otherwise would trigger a response 'BAD The specified
457 message set is invalid.'.  We don't unconditionally use this
458 form, since this is said to be significantly inefficient.
459
460 This variable is set to t automatically per server if the
461 canonical form fails.")
462
463 \f
464 ;; Utility functions:
465
466 (defun imap-remassoc (key alist)
467   "Delete by side effect any elements of ALIST whose car is `equal' to KEY.
468 The modified ALIST is returned.  If the first member
469 of ALIST has a car that is `equal' to KEY, there is no way to remove it
470 by side effect; therefore, write `(setq foo (remassoc key foo))' to be
471 sure of changing the value of `foo'."
472   (when alist
473     (if (equal key (caar alist))
474         (cdr alist)
475       (setcdr alist (imap-remassoc key (cdr alist)))
476       alist)))
477
478 (defsubst imap-disable-multibyte ()
479   "Enable multibyte in the current buffer."
480   (when (fboundp 'set-buffer-multibyte)
481     (set-buffer-multibyte nil)))
482
483 (defsubst imap-utf7-encode (string)
484   (if imap-use-utf7
485       (and string
486            (condition-case ()
487                (utf7-encode string t)
488              (error (message
489                      "imap: Could not UTF7 encode `%s', using it unencoded..."
490                      string)
491                     string)))
492     string))
493
494 (defsubst imap-utf7-decode (string)
495   (if imap-use-utf7
496       (and string
497            (condition-case ()
498                (utf7-decode string t)
499              (error (message
500                      "imap: Could not UTF7 decode `%s', using it undecoded..."
501                      string)
502                     string)))
503     string))
504
505 (defsubst imap-ok-p (status)
506   (if (eq status 'OK)
507       t
508     (setq imap-error status)
509     nil))
510
511 (defun imap-error-text (&optional buffer)
512   (with-current-buffer (or buffer (current-buffer))
513     (nth 3 (car imap-failed-tags))))
514
515 \f
516 ;; Server functions; stream stuff:
517
518 (defun imap-kerberos4-stream-p (buffer)
519   (imap-capability 'AUTH=KERBEROS_V4 buffer))
520
521 (defun imap-kerberos4-open (name buffer server port)
522   (let ((cmds imap-kerberos4-program)
523         cmd done)
524     (while (and (not done) (setq cmd (pop cmds)))
525       (message "Opening Kerberos 4 IMAP connection with `%s'..." cmd)
526       (erase-buffer)
527       (let* ((port (or port imap-default-port))
528              (coding-system-for-read imap-coding-system-for-read)
529              (coding-system-for-write imap-coding-system-for-write)
530              (process-connection-type imap-process-connection-type)
531              (process (start-process
532                        name buffer shell-file-name shell-command-switch
533                        (format-spec
534                         cmd
535                         (format-spec-make
536                          ?s server
537                          ?p (number-to-string port)
538                          ?l imap-default-user))))
539              response)
540         (when process
541           (with-current-buffer buffer
542             (setq imap-client-eol "\n"
543                   imap-calculate-literal-size-first t)
544             (while (and (memq (process-status process) '(open run))
545                         (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
546                         (goto-char (point-min))
547                         ;; Athena IMTEST can output SSL verify errors
548                         (or (while (looking-at "^verify error:num=")
549                               (forward-line))
550                             t)
551                         (or (while (looking-at "^TLS connection established")
552                               (forward-line))
553                             t)
554                         ;; cyrus 1.6.x (13? < x <= 22) queries capabilities
555                         (or (while (looking-at "^C:")
556                               (forward-line))
557                             t)
558                         ;; cyrus 1.6 imtest print "S: " before server greeting
559                         (or (not (looking-at "S: "))
560                             (forward-char 3)
561                             t)
562                         (not (and (imap-parse-greeting)
563                                   ;; success in imtest < 1.6:
564                                   (or (re-search-forward
565                                        "^__\\(.*\\)__\n" nil t)
566                                       ;; success in imtest 1.6:
567                                       (re-search-forward
568                                        "^\\(Authenticat.*\\)" nil t))
569                                   (setq response (match-string 1)))))
570               (accept-process-output process 1)
571               (sit-for 1))
572             (and imap-log
573                  (with-current-buffer (get-buffer-create imap-log-buffer)
574                    (imap-disable-multibyte)
575                    (buffer-disable-undo)
576                    (goto-char (point-max))
577                    (insert-buffer-substring buffer)))
578             (erase-buffer)
579             (message "Opening Kerberos 4 IMAP connection with `%s'...%s" cmd
580                      (if response (concat "done, " response) "failed"))
581             (if (and response (let ((case-fold-search nil))
582                                 (not (string-match "failed" response))))
583                 (setq done process)
584               (if (memq (process-status process) '(open run))
585                   (imap-logout))
586               (delete-process process)
587               nil)))))
588     done))
589
590 (defun imap-gssapi-stream-p (buffer)
591   (imap-capability 'AUTH=GSSAPI buffer))
592
593 (defun imap-gssapi-open (name buffer server port)
594   (let ((cmds imap-gssapi-program)
595         cmd done)
596     (while (and (not done) (setq cmd (pop cmds)))
597       (message "Opening GSSAPI IMAP connection with `%s'..." cmd)
598       (erase-buffer)
599       (let* ((port (or port imap-default-port))
600              (coding-system-for-read imap-coding-system-for-read)
601              (coding-system-for-write imap-coding-system-for-write)
602              (process-connection-type imap-process-connection-type)
603              (process (start-process
604                        name buffer shell-file-name shell-command-switch
605                        (format-spec
606                         cmd
607                         (format-spec-make
608                          ?s server
609                          ?p (number-to-string port)
610                          ?l imap-default-user))))
611              response)
612         (when process
613           (with-current-buffer buffer
614             (setq imap-client-eol "\n"
615                   imap-calculate-literal-size-first t)
616             (while (and (memq (process-status process) '(open run))
617                         (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
618                         (goto-char (point-min))
619                         ;; Athena IMTEST can output SSL verify errors
620                         (or (while (looking-at "^verify error:num=")
621                               (forward-line))
622                             t)
623                         (or (while (looking-at "^TLS connection established")
624                               (forward-line))
625                             t)
626                         ;; cyrus 1.6.x (13? < x <= 22) queries capabilities
627                         (or (while (looking-at "^C:")
628                               (forward-line))
629                             t)
630                         ;; cyrus 1.6 imtest print "S: " before server greeting
631                         (or (not (looking-at "S: "))
632                             (forward-char 3)
633                             t)
634                         ;; GNU SASL may print 'Trying ...' first.
635                         (or (not (looking-at "Trying "))
636                             (forward-line)
637                             t)
638                         (not (and (imap-parse-greeting)
639                                   ;; success in imtest 1.6:
640                                   (re-search-forward
641                                    (concat "^\\(\\(Authenticat.*\\)\\|\\("
642                                            "Client authentication "
643                                            "finished.*\\)\\)")
644                                    nil t)
645                                   (setq response (match-string 1)))))
646               (accept-process-output process 1)
647               (sit-for 1))
648             (and imap-log
649                  (with-current-buffer (get-buffer-create imap-log-buffer)
650                    (imap-disable-multibyte)
651                    (buffer-disable-undo)
652                    (goto-char (point-max))
653                    (insert-buffer-substring buffer)))
654             (erase-buffer)
655             (message "GSSAPI IMAP connection: %s" (or response "failed"))
656             (if (and response (let ((case-fold-search nil))
657                                 (not (string-match "failed" response))))
658                 (setq done process)
659               (if (memq (process-status process) '(open run))
660                   (imap-logout))
661               (delete-process process)
662               nil)))))
663     done))
664
665 (defun imap-ssl-p (buffer)
666   nil)
667
668 (defun imap-ssl-open (name buffer server port)
669   "Open an SSL connection to SERVER."
670   (let ((cmds (if (listp imap-ssl-program) imap-ssl-program
671                 (list imap-ssl-program)))
672         cmd done)
673     (while (and (not done) (setq cmd (pop cmds)))
674       (message "imap: Opening SSL connection with `%s'..." cmd)
675       (erase-buffer)
676       (let* ((port (or port imap-default-ssl-port))
677              (coding-system-for-read imap-coding-system-for-read)
678              (coding-system-for-write imap-coding-system-for-write)
679              (process-connection-type imap-process-connection-type)
680              (set-process-query-on-exit-flag
681               (if (fboundp 'set-process-query-on-exit-flag)
682                   'set-process-query-on-exit-flag
683                 'process-kill-without-query))
684              process)
685         (when (progn
686                 (setq process (start-process
687                                name buffer shell-file-name
688                                shell-command-switch
689                                (format-spec cmd
690                                             (format-spec-make
691                                              ?s server
692                                              ?p (number-to-string port)))))
693                 (funcall set-process-query-on-exit-flag process nil)
694                 process)
695           (with-current-buffer buffer
696             (goto-char (point-min))
697             (while (and (memq (process-status process) '(open run))
698                         (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
699                         (goto-char (point-max))
700                         (forward-line -1)
701                         (not (imap-parse-greeting)))
702               (accept-process-output process 1)
703               (sit-for 1))
704             (and imap-log
705                  (with-current-buffer (get-buffer-create imap-log-buffer)
706                    (imap-disable-multibyte)
707                    (buffer-disable-undo)
708                    (goto-char (point-max))
709                    (insert-buffer-substring buffer)))
710             (erase-buffer)
711             (when (memq (process-status process) '(open run))
712               (setq done process))))))
713     (if done
714         (progn
715           (message "imap: Opening SSL connection with `%s'...done" cmd)
716           done)
717       (message "imap: Opening SSL connection with `%s'...failed" cmd)
718       nil)))
719
720 (defun imap-tls-p (buffer)
721   nil)
722
723 (defun imap-tls-open (name buffer server port)
724   (let* ((port (or port imap-default-tls-port))
725          (coding-system-for-read imap-coding-system-for-read)
726          (coding-system-for-write imap-coding-system-for-write)
727          (process (open-tls-stream name buffer server port)))
728     (when process
729       (while (and (memq (process-status process) '(open run))
730                   ;; FIXME: Per the "blue moon" comment, the process/buffer
731                   ;; handling here, and elsewhere in functions which open
732                   ;; streams, looks confused.  Obviously we can change buffers
733                   ;; if a different process handler kicks in from
734                   ;; `accept-process-output' or `sit-for' below, and TRT seems
735                   ;; to be to `save-buffer' around those calls.  (I wonder why
736                   ;; `sit-for' is used with a non-zero wait.)  -- fx
737                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
738                   (goto-char (point-max))
739                   (forward-line -1)
740                   (not (imap-parse-greeting)))
741         (accept-process-output process 1)
742         (sit-for 1))
743       (and imap-log
744            (with-current-buffer (get-buffer-create imap-log-buffer)
745              (imap-disable-multibyte)
746              (buffer-disable-undo)
747              (goto-char (point-max))
748              (insert-buffer-substring buffer)))
749       (when (memq (process-status process) '(open run))
750         process))))
751
752 (defun imap-network-p (buffer)
753   t)
754
755 (defun imap-network-open (name buffer server port)
756   (let* ((port (or port imap-default-port))
757          (coding-system-for-read imap-coding-system-for-read)
758          (coding-system-for-write imap-coding-system-for-write)
759          (process (open-network-stream name buffer server port)))
760     (when process
761       (while (and (memq (process-status process) '(open run))
762                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
763                   (goto-char (point-min))
764                   (not (imap-parse-greeting)))
765         (accept-process-output process 1)
766         (sit-for 1))
767       (and imap-log
768            (with-current-buffer (get-buffer-create imap-log-buffer)
769              (imap-disable-multibyte)
770              (buffer-disable-undo)
771              (goto-char (point-max))
772              (insert-buffer-substring buffer)))
773       (when (memq (process-status process) '(open run))
774         process))))
775
776 (defun imap-shell-p (buffer)
777   nil)
778
779 (defun imap-shell-open (name buffer server port)
780   (let ((cmds (if (listp imap-shell-program) imap-shell-program
781                 (list imap-shell-program)))
782         cmd done)
783     (while (and (not done) (setq cmd (pop cmds)))
784       (message "imap: Opening IMAP connection with `%s'..." cmd)
785       (setq imap-client-eol "\n")
786       (let* ((port (or port imap-default-port))
787              (coding-system-for-read imap-coding-system-for-read)
788              (coding-system-for-write imap-coding-system-for-write)
789              (process (start-process
790                        name buffer shell-file-name shell-command-switch
791                        (format-spec
792                         cmd
793                         (format-spec-make
794                          ?s server
795                          ?g imap-shell-host
796                          ?p (number-to-string port)
797                          ?l imap-default-user)))))
798         (when process
799           (while (and (memq (process-status process) '(open run))
800                       (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
801                       (goto-char (point-max))
802                       (forward-line -1)
803                       (not (imap-parse-greeting)))
804             (accept-process-output process 1)
805             (sit-for 1))
806           (and imap-log
807                (with-current-buffer (get-buffer-create imap-log-buffer)
808                  (imap-disable-multibyte)
809                  (buffer-disable-undo)
810                  (goto-char (point-max))
811                  (insert-buffer-substring buffer)))
812           (erase-buffer)
813           (when (memq (process-status process) '(open run))
814             (setq done process)))))
815     (if done
816         (progn
817           (message "imap: Opening IMAP connection with `%s'...done" cmd)
818           done)
819       (message "imap: Opening IMAP connection with `%s'...failed" cmd)
820       nil)))
821
822 (defun imap-starttls-p (buffer)
823   (imap-capability 'STARTTLS buffer))
824
825 (defun imap-starttls-open (name buffer server port)
826   (let* ((port (or port imap-default-port))
827          (coding-system-for-read imap-coding-system-for-read)
828          (coding-system-for-write imap-coding-system-for-write)
829          (process (starttls-open-stream name buffer server port))
830          done tls-info)
831     (message "imap: Connecting with STARTTLS...")
832     (when process
833       (while (and (memq (process-status process) '(open run))
834                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
835                   (goto-char (point-max))
836                   (forward-line -1)
837                   (not (imap-parse-greeting)))
838         (accept-process-output process 1)
839         (sit-for 1))
840       (imap-send-command "STARTTLS")
841       (while (and (memq (process-status process) '(open run))
842                   (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
843                   (goto-char (point-max))
844                   (forward-line -1)
845                   (not (re-search-forward "[0-9]+ OK.*\r?\n" nil t)))
846         (accept-process-output process 1)
847         (sit-for 1))
848       (and imap-log
849            (with-current-buffer (get-buffer-create imap-log-buffer)
850              (buffer-disable-undo)
851              (goto-char (point-max))
852              (insert-buffer-substring buffer)))
853       (when (and (setq tls-info (starttls-negotiate process))
854                  (memq (process-status process) '(open run)))
855         (setq done process)))
856     (if (stringp tls-info)
857         (message "imap: STARTTLS info: %s" tls-info))
858     (message "imap: Connecting with STARTTLS...%s" (if done "done" "failed"))
859     done))
860
861 ;; Server functions; authenticator stuff:
862
863 (defun imap-interactive-login (buffer loginfunc)
864   "Login to server in BUFFER.
865 LOGINFUNC is passed a username and a password, it should return t if
866 it where successful authenticating itself to the server, nil otherwise.
867 Returns t if login was successful, nil otherwise."
868   (with-current-buffer buffer
869     (make-local-variable 'imap-username)
870     (make-local-variable 'imap-password)
871     (let (user passwd ret)
872       ;;      (condition-case ()
873       (while (or (not user) (not passwd))
874         (setq user (or imap-username
875                        (read-from-minibuffer
876                         (concat "imap: username for " imap-server
877                                 " (using stream `" (symbol-name imap-stream)
878                                 "'): ")
879                         (or user imap-default-user))))
880         (setq passwd (or imap-password
881                          (read-passwd
882                           (concat "imap: password for " user "@"
883                                   imap-server " (using authenticator `"
884                                   (symbol-name imap-auth) "'): "))))
885         (when (and user passwd)
886           (if (funcall loginfunc user passwd)
887               (progn
888                 (message "imap: Login successful...")
889                 (setq ret t
890                       imap-username user)
891                 (when (and (not imap-password)
892                            (or imap-store-password
893                                (y-or-n-p "imap: Store password for this IMAP session? ")))
894                   (setq imap-password passwd)))
895             (message "imap: Login failed...")
896             (setq passwd nil)
897             (setq imap-password nil)
898             (sit-for 1))))
899       ;;        (quit (with-current-buffer buffer
900       ;;                (setq user nil
901       ;;                      passwd nil)))
902       ;;        (error (with-current-buffer buffer
903       ;;                 (setq user nil
904       ;;                       passwd nil))))
905       ret)))
906
907 (defun imap-gssapi-auth-p (buffer)
908   (eq imap-stream 'gssapi))
909
910 (defun imap-gssapi-auth (buffer)
911   (message "imap: Authenticating using GSSAPI...%s"
912            (if (eq imap-stream 'gssapi) "done" "failed"))
913   (eq imap-stream 'gssapi))
914
915 (defun imap-kerberos4-auth-p (buffer)
916   (and (imap-capability 'AUTH=KERBEROS_V4 buffer)
917        (eq imap-stream 'kerberos4)))
918
919 (defun imap-kerberos4-auth (buffer)
920   (message "imap: Authenticating using Kerberos 4...%s"
921            (if (eq imap-stream 'kerberos4) "done" "failed"))
922   (eq imap-stream 'kerberos4))
923
924 (defun imap-cram-md5-p (buffer)
925   (imap-capability 'AUTH=CRAM-MD5 buffer))
926
927 (defun imap-cram-md5-auth (buffer)
928   "Login to server using the AUTH CRAM-MD5 method."
929   (message "imap: Authenticating using CRAM-MD5...")
930   (let ((done (imap-interactive-login
931                buffer
932                (lambda (user passwd)
933                  (imap-ok-p
934                   (imap-send-command-wait
935                    (list
936                     "AUTHENTICATE CRAM-MD5"
937                     (lambda (challenge)
938                       (let* ((decoded (base64-decode-string challenge))
939                              (hash (rfc2104-hash 'md5 64 16 passwd decoded))
940                              (response (concat user " " hash))
941                              (encoded (base64-encode-string response)))
942                         encoded)))))))))
943     (if done
944         (message "imap: Authenticating using CRAM-MD5...done")
945       (message "imap: Authenticating using CRAM-MD5...failed"))))
946
947 (defun imap-login-p (buffer)
948   (and (not (imap-capability 'LOGINDISABLED buffer))
949        (not (imap-capability 'X-LOGIN-CMD-DISABLED buffer))))
950
951 (defun imap-quote-specials (string)
952   (with-temp-buffer
953     (insert string)
954     (goto-char (point-min))
955     (while (re-search-forward "[\\\"]" nil t)
956       (forward-char -1)
957       (insert "\\")
958       (forward-char 1))
959     (buffer-string)))
960
961 (defun imap-login-auth (buffer)
962   "Login to server using the LOGIN command."
963   (message "imap: Plaintext authentication...")
964   (imap-interactive-login buffer
965                           (lambda (user passwd)
966                             (imap-ok-p (imap-send-command-wait
967                                         (concat "LOGIN \""
968                                                 (imap-quote-specials user)
969                                                 "\" \""
970                                                 (imap-quote-specials passwd)
971                                                 "\""))))))
972
973 (defun imap-anonymous-p (buffer)
974   t)
975
976 (defun imap-anonymous-auth (buffer)
977   (message "imap: Logging in anonymously...")
978   (with-current-buffer buffer
979     (imap-ok-p (imap-send-command-wait
980                 (concat "LOGIN anonymous \"" (concat (user-login-name) "@"
981                                                      (system-name)) "\"")))))
982
983 ;;; Compiler directives.
984
985 (defvar imap-sasl-client)
986 (defvar imap-sasl-step)
987
988 (defun imap-sasl-make-mechanisms (buffer)
989   (let ((mecs '()))
990     (mapc (lambda (sym)
991             (let ((name (symbol-name sym)))
992               (if (and (> (length name) 5)
993                        (string-equal "AUTH=" (substring name 0 5 )))
994                   (setq mecs (cons (substring name 5) mecs)))))
995           (imap-capability nil buffer))
996     mecs))
997
998 (declare-function sasl-find-mechanism "sasl" (mechanism))
999 (declare-function sasl-mechanism-name "sasl" (mechanism))
1000 (declare-function sasl-make-client    "sasl" (mechanism name service server))
1001 (declare-function sasl-next-step      "sasl" (client step))
1002 (declare-function sasl-step-data      "sasl" (step))
1003 (declare-function sasl-step-set-data  "sasl" (step data))
1004
1005 (defun imap-sasl-auth-p (buffer)
1006   (and (condition-case ()
1007            (require 'sasl)
1008          (error nil))
1009        (sasl-find-mechanism (imap-sasl-make-mechanisms buffer))))
1010
1011 (defun imap-sasl-auth (buffer)
1012   "Login to server using the SASL method."
1013   (message "imap: Authenticating using SASL...")
1014   (with-current-buffer buffer
1015     (make-local-variable 'imap-username)
1016     (make-local-variable 'imap-sasl-client)
1017     (make-local-variable 'imap-sasl-step)
1018     (let ((mechanism (sasl-find-mechanism (imap-sasl-make-mechanisms buffer)))
1019           logged user)
1020       (while (not logged)
1021         (setq user (or imap-username
1022                        (read-from-minibuffer
1023                         (concat "IMAP username for " imap-server " using SASL "
1024                                 (sasl-mechanism-name mechanism) ": ")
1025                         (or user imap-default-user))))
1026         (when user
1027           (setq imap-sasl-client (sasl-make-client mechanism user "imap2" imap-server)
1028                 imap-sasl-step (sasl-next-step imap-sasl-client nil))
1029           (let ((tag (imap-send-command
1030                       (if (sasl-step-data imap-sasl-step)
1031                           (format "AUTHENTICATE %s %s"
1032                                   (sasl-mechanism-name mechanism)
1033                                   (sasl-step-data imap-sasl-step))
1034                         (format "AUTHENTICATE %s" (sasl-mechanism-name mechanism)))
1035                       buffer)))
1036             (while (eq (imap-wait-for-tag tag) 'INCOMPLETE)
1037               (sasl-step-set-data imap-sasl-step (base64-decode-string imap-continuation))
1038               (setq imap-continuation nil
1039                     imap-sasl-step (sasl-next-step imap-sasl-client imap-sasl-step))
1040               (imap-send-command-1 (if (sasl-step-data imap-sasl-step)
1041                                        (base64-encode-string (sasl-step-data imap-sasl-step) t)
1042                                      "")))
1043             (if (imap-ok-p (imap-wait-for-tag tag))
1044                 (setq imap-username user
1045                       logged t)
1046               (message "Login failed...")
1047               (sit-for 1)))))
1048       logged)))
1049
1050 (defun imap-digest-md5-p (buffer)
1051   (and (imap-capability 'AUTH=DIGEST-MD5 buffer)
1052        (condition-case ()
1053            (require 'digest-md5)
1054          (error nil))))
1055
1056 (defun imap-digest-md5-auth (buffer)
1057   "Login to server using the AUTH DIGEST-MD5 method."
1058   (message "imap: Authenticating using DIGEST-MD5...")
1059   (imap-interactive-login
1060    buffer
1061    (lambda (user passwd)
1062      (let ((tag
1063             (imap-send-command
1064              (list
1065               "AUTHENTICATE DIGEST-MD5"
1066               (lambda (challenge)
1067                 (digest-md5-parse-digest-challenge
1068                  (base64-decode-string challenge))
1069                 (let* ((digest-uri
1070                         (digest-md5-digest-uri
1071                          "imap" (digest-md5-challenge 'realm)))
1072                        (response
1073                         (digest-md5-digest-response
1074                          user passwd digest-uri)))
1075                   (base64-encode-string response 'no-line-break))))
1076              )))
1077        (if (not (eq (imap-wait-for-tag tag) 'INCOMPLETE))
1078            nil
1079          (setq imap-continuation nil)
1080          (imap-send-command-1 "")
1081          (imap-ok-p (imap-wait-for-tag tag)))))))
1082
1083 ;; Server functions:
1084
1085 (defun imap-open-1 (buffer)
1086   (with-current-buffer buffer
1087     (erase-buffer)
1088     (setq imap-current-mailbox nil
1089           imap-current-message nil
1090           imap-state 'initial
1091           imap-process (condition-case ()
1092                            (funcall (nth 2 (assq imap-stream
1093                                                  imap-stream-alist))
1094                                     "imap" buffer imap-server imap-port)
1095                          ((error quit) nil)))
1096     (when imap-process
1097       (set-process-filter imap-process 'imap-arrival-filter)
1098       (set-process-sentinel imap-process 'imap-sentinel)
1099       (while (and (eq imap-state 'initial)
1100                   (memq (process-status imap-process) '(open run)))
1101         (message "Waiting for response from %s..." imap-server)
1102         (accept-process-output imap-process 1))
1103       (message "Waiting for response from %s...done" imap-server)
1104       (and (memq (process-status imap-process) '(open run))
1105            imap-process))))
1106
1107 (defun imap-open (server &optional port stream auth buffer)
1108   "Open an IMAP connection to host SERVER at PORT returning a buffer.
1109 If PORT is unspecified, a default value is used (143 except
1110 for SSL which use 993).
1111 STREAM indicates the stream to use, see `imap-streams' for available
1112 streams.  If nil, it choices the best stream the server is capable of.
1113 AUTH indicates authenticator to use, see `imap-authenticators' for
1114 available authenticators.  If nil, it choices the best stream the
1115 server is capable of.
1116 BUFFER can be a buffer or a name of a buffer, which is created if
1117 necessary.  If nil, the buffer name is generated."
1118   (setq buffer (or buffer (format " *imap* %s:%d" server (or port 0))))
1119   (with-current-buffer (get-buffer-create buffer)
1120     (if (imap-opened buffer)
1121         (imap-close buffer))
1122     (mapc 'make-local-variable imap-local-variables)
1123     (imap-disable-multibyte)
1124     (buffer-disable-undo)
1125     (setq imap-server (or server imap-server))
1126     (setq imap-port (or port imap-port))
1127     (setq imap-auth (or auth imap-auth))
1128     (setq imap-stream (or stream imap-stream))
1129     (message "imap: Connecting to %s..." imap-server)
1130     (if (null (let ((imap-stream (or imap-stream imap-default-stream)))
1131                 (imap-open-1 buffer)))
1132         (progn
1133           (message "imap: Connecting to %s...failed" imap-server)
1134           nil)
1135       (when (null imap-stream)
1136         ;; Need to choose stream.
1137         (let ((streams imap-streams))
1138           (while (setq stream (pop streams))
1139             ;; OK to use this stream?
1140             (when (funcall (nth 1 (assq stream imap-stream-alist)) buffer)
1141               ;; Stream changed?
1142               (if (not (eq imap-default-stream stream))
1143                   (with-current-buffer (get-buffer-create
1144                                         (generate-new-buffer-name " *temp*"))
1145                     (mapc 'make-local-variable imap-local-variables)
1146                     (imap-disable-multibyte)
1147                     (buffer-disable-undo)
1148                     (setq imap-server (or server imap-server))
1149                     (setq imap-port (or port imap-port))
1150                     (setq imap-auth (or auth imap-auth))
1151                     (message "imap: Reconnecting with stream `%s'..." stream)
1152                     (if (null (let ((imap-stream stream))
1153                                 (imap-open-1 (current-buffer))))
1154                         (progn
1155                           (kill-buffer (current-buffer))
1156                           (message
1157                            "imap: Reconnecting with stream `%s'...failed"
1158                            stream))
1159                       ;; We're done, kill the first connection
1160                       (imap-close buffer)
1161                       (let ((name (if (stringp buffer)
1162                                       buffer
1163                                     (buffer-name buffer))))
1164                         (kill-buffer buffer)
1165                         (rename-buffer name)
1166                         ;; set the passed buffer to the current one,
1167                         ;; so that (imap-opened buffer) later will work
1168                         (setq buffer (current-buffer)))
1169                       (message "imap: Reconnecting with stream `%s'...done"
1170                                stream)
1171                       (setq imap-stream stream)
1172                       (setq imap-capability nil)
1173                       (setq streams nil)))
1174                 ;; We're done
1175                 (message "imap: Connecting to %s...done" imap-server)
1176                 (setq imap-stream stream)
1177                 (setq imap-capability nil)
1178                 (setq streams nil))))))
1179       (when (imap-opened buffer)
1180         (setq imap-mailbox-data (make-vector imap-mailbox-prime 0)))
1181       ;; (debug "opened+state+auth+buffer" (imap-opened buffer) imap-state imap-auth buffer)
1182       (when imap-stream
1183         buffer))))
1184
1185 (defcustom imap-ping-server t
1186   "If non-nil, check if IMAP is open.
1187 See the function `imap-ping-server'."
1188   :version "23.1" ;; No Gnus
1189   :group 'imap
1190   :type 'boolean)
1191
1192 (defun imap-opened (&optional buffer)
1193   "Return non-nil if connection to imap server in BUFFER is open.
1194 If BUFFER is nil then the current buffer is used."
1195   (and (setq buffer (get-buffer (or buffer (current-buffer))))
1196        (buffer-live-p buffer)
1197        (with-current-buffer buffer
1198          (and imap-process
1199               (memq (process-status imap-process) '(open run))
1200               (if imap-ping-server
1201                   (imap-ping-server)
1202                 t)))))
1203
1204 (defun imap-ping-server (&optional buffer)
1205   "Ping the IMAP server in BUFFER with a \"NOOP\" command.
1206 Return non-nil if the server responds, and nil if it does not
1207 respond.  If BUFFER is nil, the current buffer is used."
1208   (condition-case ()
1209       (imap-ok-p (imap-send-command-wait "NOOP" buffer))
1210     (error nil)))
1211
1212 (defun imap-authenticate (&optional user passwd buffer)
1213   "Authenticate to server in BUFFER, using current buffer if nil.
1214 It uses the authenticator specified when opening the server.  If the
1215 authenticator requires username/passwords, they are queried from the
1216 user and optionally stored in the buffer.  If USER and/or PASSWD is
1217 specified, the user will not be questioned and the username and/or
1218 password is remembered in the buffer."
1219   (with-current-buffer (or buffer (current-buffer))
1220     (if (not (eq imap-state 'nonauth))
1221         (or (eq imap-state 'auth)
1222             (eq imap-state 'selected)
1223             (eq imap-state 'examine))
1224       (make-local-variable 'imap-username)
1225       (make-local-variable 'imap-password)
1226       (make-local-variable 'imap-last-authenticator)
1227       (when user (setq imap-username user))
1228       (when passwd (setq imap-password passwd))
1229       (if imap-auth
1230           (and (setq imap-last-authenticator 
1231                      (assq imap-auth imap-authenticator-alist))
1232                (funcall (nth 2 imap-last-authenticator) (current-buffer))
1233                (setq imap-state 'auth))
1234         ;; Choose authenticator.
1235         (let ((auths imap-authenticators)
1236               auth)
1237           (while (setq auth (pop auths))
1238             ;; OK to use authenticator?
1239             (setq imap-last-authenticator
1240                   (assq auth imap-authenticator-alist))
1241             (when (funcall (nth 1 imap-last-authenticator) (current-buffer))
1242               (message "imap: Authenticating to `%s' using `%s'..."
1243                        imap-server auth)
1244               (setq imap-auth auth)
1245               (if (funcall (nth 2 imap-last-authenticator) (current-buffer))
1246                   (progn
1247                     (message "imap: Authenticating to `%s' using `%s'...done"
1248                              imap-server auth)
1249                     ;; set imap-state correctly on successful auth attempt
1250                     (setq imap-state 'auth)
1251                     ;; stop iterating through the authenticator list
1252                     (setq auths nil))
1253                 (message "imap: Authenticating to `%s' using `%s'...failed"
1254                          imap-server auth)))))
1255         imap-state))))
1256
1257 (defun imap-close (&optional buffer)
1258   "Close connection to server in BUFFER.
1259 If BUFFER is nil, the current buffer is used."
1260   (with-current-buffer (or buffer (current-buffer))
1261     (when (imap-opened)
1262       (condition-case nil
1263           (imap-logout-wait)
1264         (quit nil)))
1265     (when (and imap-process
1266                (memq (process-status imap-process) '(open run)))
1267       (delete-process imap-process))
1268     (setq imap-current-mailbox nil
1269           imap-current-message nil
1270           imap-process nil)
1271     (erase-buffer)
1272     t))
1273
1274 (defun imap-capability (&optional identifier buffer)
1275   "Return a list of identifiers which server in BUFFER support.
1276 If IDENTIFIER, return non-nil if it's among the servers capabilities.
1277 If BUFFER is nil, the current buffer is assumed."
1278   (with-current-buffer (or buffer (current-buffer))
1279     (unless imap-capability
1280       (unless (imap-ok-p (imap-send-command-wait "CAPABILITY"))
1281         (setq imap-capability '(IMAP2))))
1282     (if identifier
1283         (memq (intern (upcase (symbol-name identifier))) imap-capability)
1284       imap-capability)))
1285
1286 (defun imap-id (&optional list-of-values buffer)
1287   "Identify client to server in BUFFER, and return server identity.
1288 LIST-OF-VALUES is nil, or a plist with identifier and value
1289 strings to send to the server to identify the client.
1290
1291 Return a list of identifiers which server in BUFFER support, or
1292 nil if it doesn't support ID or returns no information.
1293
1294 If BUFFER is nil, the current buffer is assumed."
1295   (with-current-buffer (or buffer (current-buffer))
1296     (when (and (imap-capability 'ID)
1297                (imap-ok-p (imap-send-command-wait
1298                            (if (null list-of-values)
1299                                "ID NIL"
1300                              (concat "ID (" (mapconcat (lambda (el)
1301                                                          (concat "\"" el "\""))
1302                                                        list-of-values
1303                                                        " ") ")")))))
1304       imap-id)))
1305
1306 (defun imap-namespace (&optional buffer)
1307   "Return a namespace hierarchy at server in BUFFER.
1308 If BUFFER is nil, the current buffer is assumed."
1309   (with-current-buffer (or buffer (current-buffer))
1310     (unless imap-namespace
1311       (when (imap-capability 'NAMESPACE)
1312         (imap-send-command-wait "NAMESPACE")))
1313     imap-namespace))
1314
1315 (defun imap-send-command-wait (command &optional buffer)
1316   (imap-wait-for-tag (imap-send-command command buffer) buffer))
1317
1318 (defun imap-logout (&optional buffer)
1319   (or buffer (setq buffer (current-buffer)))
1320   (if imap-logout-timeout
1321       (with-timeout (imap-logout-timeout
1322                      (condition-case nil
1323                          (with-current-buffer buffer
1324                            (delete-process imap-process))
1325                        (error)))
1326         (imap-send-command "LOGOUT" buffer))
1327     (imap-send-command "LOGOUT" buffer)))
1328
1329 (defun imap-logout-wait (&optional buffer)
1330   (or buffer (setq buffer (current-buffer)))
1331   (if imap-logout-timeout
1332       (with-timeout (imap-logout-timeout
1333                      (condition-case nil
1334                          (with-current-buffer buffer
1335                            (delete-process imap-process))
1336                        (error)))
1337         (imap-send-command-wait "LOGOUT" buffer))
1338     (imap-send-command-wait "LOGOUT" buffer)))
1339
1340 \f
1341 ;; Mailbox functions:
1342
1343 (defun imap-mailbox-put (propname value &optional mailbox buffer)
1344   (with-current-buffer (or buffer (current-buffer))
1345     (if imap-mailbox-data
1346         (put (intern (or mailbox imap-current-mailbox) imap-mailbox-data)
1347              propname value)
1348       (error "Imap-mailbox-data is nil, prop %s value %s mailbox %s buffer %s"
1349              propname value mailbox (current-buffer)))
1350     t))
1351
1352 (defsubst imap-mailbox-get-1 (propname &optional mailbox)
1353   (get (intern-soft (or mailbox imap-current-mailbox) imap-mailbox-data)
1354        propname))
1355
1356 (defun imap-mailbox-get (propname &optional mailbox buffer)
1357   (let ((mailbox (imap-utf7-encode mailbox)))
1358     (with-current-buffer (or buffer (current-buffer))
1359       (imap-mailbox-get-1 propname (or mailbox imap-current-mailbox)))))
1360
1361 (defun imap-mailbox-map-1 (func &optional mailbox-decoder buffer)
1362   (with-current-buffer (or buffer (current-buffer))
1363     (let (result)
1364       (mapatoms
1365        (lambda (s)
1366          (push (funcall func (if mailbox-decoder
1367                                  (funcall mailbox-decoder (symbol-name s))
1368                                (symbol-name s))) result))
1369        imap-mailbox-data)
1370       result)))
1371
1372 (defun imap-mailbox-map (func &optional buffer)
1373   "Map a function across each mailbox in `imap-mailbox-data', returning a list.
1374 Function should take a mailbox name (a string) as
1375 the only argument."
1376   (imap-mailbox-map-1 func 'imap-utf7-decode buffer))
1377
1378 (defun imap-current-mailbox (&optional buffer)
1379   (with-current-buffer (or buffer (current-buffer))
1380     (imap-utf7-decode imap-current-mailbox)))
1381
1382 (defun imap-current-mailbox-p-1 (mailbox &optional examine)
1383   (and (string= mailbox imap-current-mailbox)
1384        (or (and examine
1385                 (eq imap-state 'examine))
1386            (and (not examine)
1387                 (eq imap-state 'selected)))))
1388
1389 (defun imap-current-mailbox-p (mailbox &optional examine buffer)
1390   (with-current-buffer (or buffer (current-buffer))
1391     (imap-current-mailbox-p-1 (imap-utf7-encode mailbox) examine)))
1392
1393 (defun imap-mailbox-select-1 (mailbox &optional examine)
1394   "Select MAILBOX on server in BUFFER.
1395 If EXAMINE is non-nil, do a read-only select."
1396   (if (imap-current-mailbox-p-1 mailbox examine)
1397       imap-current-mailbox
1398     (setq imap-current-mailbox mailbox)
1399     (if (imap-ok-p (imap-send-command-wait
1400                     (concat (if examine "EXAMINE" "SELECT") " \""
1401                             mailbox "\"")))
1402         (progn
1403           (setq imap-message-data (make-vector imap-message-prime 0)
1404                 imap-state (if examine 'examine 'selected))
1405           imap-current-mailbox)
1406       ;; Failed SELECT/EXAMINE unselects current mailbox
1407       (setq imap-current-mailbox nil))))
1408
1409 (defun imap-mailbox-select (mailbox &optional examine buffer)
1410   (with-current-buffer (or buffer (current-buffer))
1411     (imap-utf7-decode
1412      (imap-mailbox-select-1 (imap-utf7-encode mailbox) examine))))
1413
1414 (defun imap-mailbox-examine-1 (mailbox &optional buffer)
1415   (with-current-buffer (or buffer (current-buffer))
1416     (imap-mailbox-select-1 mailbox 'examine)))
1417
1418 (defun imap-mailbox-examine (mailbox &optional buffer)
1419   "Examine MAILBOX on server in BUFFER."
1420   (imap-mailbox-select mailbox 'examine buffer))
1421
1422 (defun imap-mailbox-unselect (&optional buffer)
1423   "Close current folder in BUFFER, without expunging articles."
1424   (with-current-buffer (or buffer (current-buffer))
1425     (when (or (eq imap-state 'auth)
1426               (and (imap-capability 'UNSELECT)
1427                    (imap-ok-p (imap-send-command-wait "UNSELECT")))
1428               (and (imap-ok-p
1429                     (imap-send-command-wait (concat "EXAMINE \""
1430                                                     imap-current-mailbox
1431                                                     "\"")))
1432                    (imap-ok-p (imap-send-command-wait "CLOSE"))))
1433       (setq imap-current-mailbox nil
1434             imap-message-data nil
1435             imap-state 'auth)
1436       t)))
1437
1438 (defun imap-mailbox-expunge (&optional asynch buffer)
1439   "Expunge articles in current folder in BUFFER.
1440 If ASYNCH, do not wait for successful completion of the command.
1441 If BUFFER is nil the current buffer is assumed."
1442   (with-current-buffer (or buffer (current-buffer))
1443     (when (and imap-current-mailbox (not (eq imap-state 'examine)))
1444       (if asynch
1445           (imap-send-command "EXPUNGE")
1446       (imap-ok-p (imap-send-command-wait "EXPUNGE"))))))
1447
1448 (defun imap-mailbox-close (&optional asynch buffer)
1449   "Expunge articles and close current folder in BUFFER.
1450 If ASYNCH, do not wait for successful completion of the command.
1451 If BUFFER is nil the current buffer is assumed."
1452   (with-current-buffer (or buffer (current-buffer))
1453     (when imap-current-mailbox
1454       (if asynch
1455           (imap-add-callback (imap-send-command "CLOSE")
1456                              `(lambda (tag status)
1457                                 (message "IMAP mailbox `%s' closed... %s"
1458                                          imap-current-mailbox status)
1459                                 (when (eq ,imap-current-mailbox
1460                                           imap-current-mailbox)
1461                                   ;; Don't wipe out data if another mailbox
1462                                   ;; was selected...
1463                                   (setq imap-current-mailbox nil
1464                                         imap-message-data nil
1465                                         imap-state 'auth))))
1466         (when (imap-ok-p (imap-send-command-wait "CLOSE"))
1467           (setq imap-current-mailbox nil
1468                 imap-message-data nil
1469                 imap-state 'auth)))
1470       t)))
1471
1472 (defun imap-mailbox-create-1 (mailbox)
1473   (imap-ok-p (imap-send-command-wait (list "CREATE \"" mailbox "\""))))
1474
1475 (defun imap-mailbox-create (mailbox &optional buffer)
1476   "Create MAILBOX on server in BUFFER.
1477 If BUFFER is nil the current buffer is assumed."
1478   (with-current-buffer (or buffer (current-buffer))
1479     (imap-mailbox-create-1 (imap-utf7-encode mailbox))))
1480
1481 (defun imap-mailbox-delete (mailbox &optional buffer)
1482   "Delete MAILBOX on server in BUFFER.
1483 If BUFFER is nil the current buffer is assumed."
1484   (let ((mailbox (imap-utf7-encode mailbox)))
1485     (with-current-buffer (or buffer (current-buffer))
1486       (imap-ok-p
1487        (imap-send-command-wait (list "DELETE \"" mailbox "\""))))))
1488
1489 (defun imap-mailbox-rename (oldname newname &optional buffer)
1490   "Rename mailbox OLDNAME to NEWNAME on server in BUFFER.
1491 If BUFFER is nil the current buffer is assumed."
1492   (let ((oldname (imap-utf7-encode oldname))
1493         (newname (imap-utf7-encode newname)))
1494     (with-current-buffer (or buffer (current-buffer))
1495       (imap-ok-p
1496        (imap-send-command-wait (list "RENAME \"" oldname "\" "
1497                                      "\"" newname "\""))))))
1498
1499 (defun imap-mailbox-lsub (&optional root reference add-delimiter buffer)
1500   "Return a list of subscribed mailboxes on server in BUFFER.
1501 If ROOT is non-nil, only list matching mailboxes.  If ADD-DELIMITER is
1502 non-nil, a hierarchy delimiter is added to root.  REFERENCE is a
1503 implementation-specific string that has to be passed to lsub command."
1504   (with-current-buffer (or buffer (current-buffer))
1505     ;; Make sure we know the hierarchy separator for root's hierarchy
1506     (when (and add-delimiter (null (imap-mailbox-get-1 'delimiter root)))
1507       (imap-send-command-wait (concat "LIST \"" reference "\" \""
1508                                       (imap-utf7-encode root) "\"")))
1509     ;; clear list data (NB not delimiter and other stuff)
1510     (imap-mailbox-map-1 (lambda (mailbox)
1511                           (imap-mailbox-put 'lsub nil mailbox)))
1512     (when (imap-ok-p
1513            (imap-send-command-wait
1514             (concat "LSUB \"" reference "\" \"" (imap-utf7-encode root)
1515                     (and add-delimiter (imap-mailbox-get-1 'delimiter root))
1516                     "%\"")))
1517       (let (out)
1518         (imap-mailbox-map-1 (lambda (mailbox)
1519                               (when (imap-mailbox-get-1 'lsub mailbox)
1520                                 (push (imap-utf7-decode mailbox) out))))
1521         (nreverse out)))))
1522
1523 (defun imap-mailbox-list (root &optional reference add-delimiter buffer)
1524   "Return a list of mailboxes matching ROOT on server in BUFFER.
1525 If ADD-DELIMITER is non-nil, a hierarchy delimiter is added to
1526 root.  REFERENCE is a implementation-specific string that has to be
1527 passed to list command."
1528   (with-current-buffer (or buffer (current-buffer))
1529     ;; Make sure we know the hierarchy separator for root's hierarchy
1530     (when (and add-delimiter (null (imap-mailbox-get-1 'delimiter root)))
1531       (imap-send-command-wait (concat "LIST \"" reference "\" \""
1532                                       (imap-utf7-encode root) "\"")))
1533     ;; clear list data (NB not delimiter and other stuff)
1534     (imap-mailbox-map-1 (lambda (mailbox)
1535                           (imap-mailbox-put 'list nil mailbox)))
1536     (when (imap-ok-p
1537            (imap-send-command-wait
1538             (concat "LIST \"" reference "\" \"" (imap-utf7-encode root)
1539                     (and add-delimiter (imap-mailbox-get-1 'delimiter root))
1540                     "%\"")))
1541       (let (out)
1542         (imap-mailbox-map-1 (lambda (mailbox)
1543                               (when (imap-mailbox-get-1 'list mailbox)
1544                                 (push (imap-utf7-decode mailbox) out))))
1545         (nreverse out)))))
1546
1547 (defun imap-mailbox-subscribe (mailbox &optional buffer)
1548   "Send the SUBSCRIBE command on the MAILBOX to server in BUFFER.
1549 Returns non-nil if successful."
1550   (with-current-buffer (or buffer (current-buffer))
1551     (imap-ok-p (imap-send-command-wait (concat "SUBSCRIBE \""
1552                                                (imap-utf7-encode mailbox)
1553                                                "\"")))))
1554
1555 (defun imap-mailbox-unsubscribe (mailbox &optional buffer)
1556   "Send the SUBSCRIBE command on the MAILBOX to server in BUFFER.
1557 Returns non-nil if successful."
1558   (with-current-buffer (or buffer (current-buffer))
1559     (imap-ok-p (imap-send-command-wait (concat "UNSUBSCRIBE "
1560                                                (imap-utf7-encode mailbox)
1561                                                "\"")))))
1562
1563 (defun imap-mailbox-status (mailbox items &optional buffer)
1564   "Get status items ITEM in MAILBOX from server in BUFFER.
1565 ITEMS can be a symbol or a list of symbols, valid symbols are one of
1566 the STATUS data items -- i.e. `messages', `recent', `uidnext', `uidvalidity',
1567 or `unseen'.  If ITEMS is a list of symbols, a list of values is
1568 returned, if ITEMS is a symbol only its value is returned."
1569   (with-current-buffer (or buffer (current-buffer))
1570     (when (imap-ok-p
1571            (imap-send-command-wait (list "STATUS \""
1572                                          (imap-utf7-encode mailbox)
1573                                          "\" "
1574                                          (upcase
1575                                           (format "%s"
1576                                                   (if (listp items)
1577                                                       items
1578                                                     (list items)))))))
1579       (if (listp items)
1580           (mapcar (lambda (item)
1581                     (imap-mailbox-get item mailbox))
1582                   items)
1583         (imap-mailbox-get items mailbox)))))
1584
1585 (defun imap-mailbox-status-asynch (mailbox items &optional buffer)
1586   "Send status item request ITEM on MAILBOX to server in BUFFER.
1587 ITEMS can be a symbol or a list of symbols, valid symbols are one of
1588 the STATUS data items -- i.e. 'messages, 'recent, 'uidnext, 'uidvalidity
1589 or 'unseen.  The IMAP command tag is returned."
1590   (with-current-buffer (or buffer (current-buffer))
1591     (imap-send-command (list "STATUS \""
1592                              (imap-utf7-encode mailbox)
1593                              "\" "
1594                              (upcase
1595                               (format "%s"
1596                                       (if (listp items)
1597                                           items
1598                                         (list items))))))))
1599
1600 (defun imap-mailbox-acl-get (&optional mailbox buffer)
1601   "Get ACL on MAILBOX from server in BUFFER."
1602   (let ((mailbox (imap-utf7-encode mailbox)))
1603     (with-current-buffer (or buffer (current-buffer))
1604       (when (imap-ok-p
1605              (imap-send-command-wait (list "GETACL \""
1606                                            (or mailbox imap-current-mailbox)
1607                                            "\"")))
1608         (imap-mailbox-get-1 'acl (or mailbox imap-current-mailbox))))))
1609
1610 (defun imap-mailbox-acl-set (identifier rights &optional mailbox buffer)
1611   "Change/set ACL for IDENTIFIER to RIGHTS in MAILBOX from server in BUFFER."
1612   (let ((mailbox (imap-utf7-encode mailbox)))
1613     (with-current-buffer (or buffer (current-buffer))
1614       (imap-ok-p
1615        (imap-send-command-wait (list "SETACL \""
1616                                      (or mailbox imap-current-mailbox)
1617                                      "\" "
1618                                      identifier
1619                                      " "
1620                                      rights))))))
1621
1622 (defun imap-mailbox-acl-delete (identifier &optional mailbox buffer)
1623   "Remove any <identifier,rights> pair for IDENTIFIER in MAILBOX from server in BUFFER."
1624   (let ((mailbox (imap-utf7-encode mailbox)))
1625     (with-current-buffer (or buffer (current-buffer))
1626       (imap-ok-p
1627        (imap-send-command-wait (list "DELETEACL \""
1628                                      (or mailbox imap-current-mailbox)
1629                                      "\" "
1630                                      identifier))))))
1631
1632 \f
1633 ;; Message functions:
1634
1635 (defun imap-current-message (&optional buffer)
1636   (with-current-buffer (or buffer (current-buffer))
1637     imap-current-message))
1638
1639 (defun imap-list-to-message-set (list)
1640   (mapconcat (lambda (item)
1641                (number-to-string item))
1642              (if (listp list)
1643                  list
1644                (list list))
1645              ","))
1646
1647 (defun imap-range-to-message-set (range)
1648   (mapconcat
1649    (lambda (item)
1650      (if (consp item)
1651          (format "%d:%d"
1652                  (car item) (cdr item))
1653        (format "%d" item)))
1654    (if (and (listp range) (not (listp (cdr range))))
1655        (list range) ;; make (1 . 2) into ((1 . 2))
1656      range)
1657    ","))
1658
1659 (defun imap-fetch-asynch (uids props &optional nouidfetch buffer)
1660   (with-current-buffer (or buffer (current-buffer))
1661     (imap-send-command (format "%sFETCH %s %s" (if nouidfetch "" "UID ")
1662                                (if (listp uids)
1663                                    (imap-list-to-message-set uids)
1664                                  uids)
1665                                props))))
1666
1667 (defun imap-fetch (uids props &optional receive nouidfetch buffer)
1668   "Fetch properties PROPS from message set UIDS from server in BUFFER.
1669 UIDS can be a string, number or a list of numbers.  If RECEIVE
1670 is non-nil return these properties."
1671   (with-current-buffer (or buffer (current-buffer))
1672     (when (imap-ok-p (imap-send-command-wait
1673                       (format "%sFETCH %s %s" (if nouidfetch "" "UID ")
1674                               (if (listp uids)
1675                                   (imap-list-to-message-set uids)
1676                                 uids)
1677                               props)))
1678       (if (or (null receive) (stringp uids))
1679           t
1680         (if (listp uids)
1681             (mapcar (lambda (uid)
1682                       (if (listp receive)
1683                           (mapcar (lambda (prop)
1684                                     (imap-message-get uid prop))
1685                                   receive)
1686                         (imap-message-get uid receive)))
1687                     uids)
1688           (imap-message-get uids receive))))))
1689
1690 (defun imap-message-put (uid propname value &optional buffer)
1691   (with-current-buffer (or buffer (current-buffer))
1692     (if imap-message-data
1693         (put (intern (number-to-string uid) imap-message-data)
1694              propname value)
1695       (error "Imap-message-data is nil, uid %s prop %s value %s buffer %s"
1696              uid propname value (current-buffer)))
1697     t))
1698
1699 (defun imap-message-get (uid propname &optional buffer)
1700   (with-current-buffer (or buffer (current-buffer))
1701     (get (intern-soft (number-to-string uid) imap-message-data)
1702          propname)))
1703
1704 (defun imap-message-map (func propname &optional buffer)
1705   "Map a function across each message in `imap-message-data', returning a list."
1706   (with-current-buffer (or buffer (current-buffer))
1707     (let (result)
1708       (mapatoms
1709        (lambda (s)
1710          (push (funcall func (get s 'UID) (get s propname)) result))
1711        imap-message-data)
1712       result)))
1713
1714 (defmacro imap-message-envelope-date (uid &optional buffer)
1715   `(with-current-buffer (or ,buffer (current-buffer))
1716      (elt (imap-message-get ,uid 'ENVELOPE) 0)))
1717
1718 (defmacro imap-message-envelope-subject (uid &optional buffer)
1719   `(with-current-buffer (or ,buffer (current-buffer))
1720      (elt (imap-message-get ,uid 'ENVELOPE) 1)))
1721
1722 (defmacro imap-message-envelope-from (uid &optional buffer)
1723   `(with-current-buffer (or ,buffer (current-buffer))
1724      (elt (imap-message-get ,uid 'ENVELOPE) 2)))
1725
1726 (defmacro imap-message-envelope-sender (uid &optional buffer)
1727   `(with-current-buffer (or ,buffer (current-buffer))
1728      (elt (imap-message-get ,uid 'ENVELOPE) 3)))
1729
1730 (defmacro imap-message-envelope-reply-to (uid &optional buffer)
1731   `(with-current-buffer (or ,buffer (current-buffer))
1732      (elt (imap-message-get ,uid 'ENVELOPE) 4)))
1733
1734 (defmacro imap-message-envelope-to (uid &optional buffer)
1735   `(with-current-buffer (or ,buffer (current-buffer))
1736      (elt (imap-message-get ,uid 'ENVELOPE) 5)))
1737
1738 (defmacro imap-message-envelope-cc (uid &optional buffer)
1739   `(with-current-buffer (or ,buffer (current-buffer))
1740      (elt (imap-message-get ,uid 'ENVELOPE) 6)))
1741
1742 (defmacro imap-message-envelope-bcc (uid &optional buffer)
1743   `(with-current-buffer (or ,buffer (current-buffer))
1744      (elt (imap-message-get ,uid 'ENVELOPE) 7)))
1745
1746 (defmacro imap-message-envelope-in-reply-to (uid &optional buffer)
1747   `(with-current-buffer (or ,buffer (current-buffer))
1748      (elt (imap-message-get ,uid 'ENVELOPE) 8)))
1749
1750 (defmacro imap-message-envelope-message-id (uid &optional buffer)
1751   `(with-current-buffer (or ,buffer (current-buffer))
1752      (elt (imap-message-get ,uid 'ENVELOPE) 9)))
1753
1754 (defmacro imap-message-body (uid &optional buffer)
1755   `(with-current-buffer (or ,buffer (current-buffer))
1756      (imap-message-get ,uid 'BODY)))
1757
1758 ;; FIXME: Should this try to use CHARSET?  -- fx
1759 (defun imap-search (predicate &optional buffer)
1760   (with-current-buffer (or buffer (current-buffer))
1761     (imap-mailbox-put 'search 'dummy)
1762     (when (imap-ok-p (imap-send-command-wait (concat "UID SEARCH " predicate)))
1763       (if (eq (imap-mailbox-get-1 'search imap-current-mailbox) 'dummy)
1764           (progn
1765             (message "Missing SEARCH response to a SEARCH command (server not RFC compliant)...")
1766             nil)
1767         (imap-mailbox-get-1 'search imap-current-mailbox)))))
1768
1769 (defun imap-message-flag-permanent-p (flag &optional mailbox buffer)
1770   "Return t if FLAG can be permanently (between IMAP sessions) saved on articles, in MAILBOX on server in BUFFER."
1771   (with-current-buffer (or buffer (current-buffer))
1772     (or (member "\\*" (imap-mailbox-get 'permanentflags mailbox))
1773         (member flag (imap-mailbox-get 'permanentflags mailbox)))))
1774
1775 (defun imap-message-flags-set (articles flags &optional silent buffer)
1776   (when (and articles flags)
1777     (with-current-buffer (or buffer (current-buffer))
1778       (imap-ok-p (imap-send-command-wait
1779                   (concat "UID STORE " articles
1780                           " FLAGS" (if silent ".SILENT") " (" flags ")"))))))
1781
1782 (defun imap-message-flags-del (articles flags &optional silent buffer)
1783   (when (and articles flags)
1784     (with-current-buffer (or buffer (current-buffer))
1785       (imap-ok-p (imap-send-command-wait
1786                   (concat "UID STORE " articles
1787                           " -FLAGS" (if silent ".SILENT") " (" flags ")"))))))
1788
1789 (defun imap-message-flags-add (articles flags &optional silent buffer)
1790   (when (and articles flags)
1791     (with-current-buffer (or buffer (current-buffer))
1792       (imap-ok-p (imap-send-command-wait
1793                   (concat "UID STORE " articles
1794                           " +FLAGS" (if silent ".SILENT") " (" flags ")"))))))
1795
1796 ;; Cf. http://thread.gmane.org/gmane.emacs.gnus.general/65317/focus=65343
1797 ;; Signal an error if we'd get an integer overflow.
1798 ;;
1799 ;; FIXME: Identify relevant calls to `string-to-number' and replace them with
1800 ;; `imap-string-to-integer'.
1801 (defun imap-string-to-integer (string &optional base)
1802   (let ((number (string-to-number string base)))
1803     (if (> number most-positive-fixnum)
1804         (error
1805          (format "String %s cannot be converted to a Lisp integer" number))
1806       number)))
1807
1808 (defun imap-fetch-safe (uids props &optional receive nouidfetch buffer)
1809   "Like `imap-fetch', but DTRT with Exchange 2007 bug.
1810 However, UIDS here is a cons, where the car is the canonical form
1811 of the UIDS specification, and the cdr is the one which works with
1812 Exchange 2007 or, potentially, other buggy servers.
1813 See `imap-enable-exchange-bug-workaround'."
1814   ;; The first time we get here for a given, we'll try the canonical
1815   ;; form.  If we get the known error from the buggy server, set the
1816   ;; flag buffer-locally (to account for connections to multiple
1817   ;; servers), then re-try with the alternative UIDS spec.  We don't
1818   ;; unconditionally use the alternative form, since the
1819   ;; currently-used alternatives are seriously inefficient with some
1820   ;; servers (although they are valid).
1821   ;;
1822   ;; FIXME:  Maybe it would be cleaner to have a flag to not signal
1823   ;; the error (which otherwise gives a message), and test
1824   ;; `imap-failed-tags'.  Also, Other IMAP clients use other forms of
1825   ;; request which work with Exchange, e.g. Claws does "UID FETCH 1:*
1826   ;; (UID)" rather than "FETCH UID 1,*".  Is there a good reason not
1827   ;; to do the same?
1828   (condition-case data
1829       ;; Binding `debug-on-error' allows us to get the error from
1830       ;; `imap-parse-response' -- it's normally caught by Emacs around
1831       ;; execution of a process filter.
1832       (let ((debug-on-error t))
1833         (imap-fetch (if imap-enable-exchange-bug-workaround
1834                         (cdr uids)
1835                       (car uids))
1836                     props receive nouidfetch buffer))
1837     (error
1838      (if (and (not imap-enable-exchange-bug-workaround)
1839               ;; This is the Exchange 2007 response.  It may be more
1840               ;; robust just to check for a BAD response to the
1841               ;; attempted fetch.
1842               (string-match "The specified message set is invalid"
1843                             (cadr data)))
1844          (with-current-buffer (or buffer (current-buffer))
1845            (set (make-local-variable 'imap-enable-exchange-bug-workaround)
1846                 t)
1847            (imap-fetch (cdr uids) props receive nouidfetch))
1848        (signal (car data) (cdr data))))))
1849
1850 (defun imap-message-copyuid-1 (mailbox)
1851   (if (imap-capability 'UIDPLUS)
1852       (list (nth 0 (imap-mailbox-get-1 'copyuid mailbox))
1853             (string-to-number (nth 2 (imap-mailbox-get-1 'copyuid mailbox))))
1854     (let ((old-mailbox imap-current-mailbox)
1855           (state imap-state)
1856           (imap-message-data (make-vector 2 0)))
1857       (when (imap-mailbox-examine-1 mailbox)
1858         (prog1
1859             (and (imap-fetch-safe '("*" . "*:*") "UID")
1860                  (list (imap-mailbox-get-1 'uidvalidity mailbox)
1861                        (apply 'max (imap-message-map
1862                                     (lambda (uid prop) uid) 'UID))))
1863           (if old-mailbox
1864               (imap-mailbox-select old-mailbox (eq state 'examine))
1865             (imap-mailbox-unselect)))))))
1866
1867 (defun imap-message-copyuid (mailbox &optional buffer)
1868   (with-current-buffer (or buffer (current-buffer))
1869     (imap-message-copyuid-1 (imap-utf7-decode mailbox))))
1870
1871 (defun imap-message-copy (articles mailbox
1872                                    &optional dont-create no-copyuid buffer)
1873   "Copy ARTICLES to MAILBOX on server in BUFFER.
1874 ARTICLES is a string message set.  Create mailbox if it doesn't exist,
1875 unless DONT-CREATE is non-nil.  On success, return a list with
1876 the UIDVALIDITY of the mailbox the article(s) was copied to as the
1877 first element.  The rest of list contains the saved articles' UIDs."
1878   (when articles
1879     (with-current-buffer (or buffer (current-buffer))
1880       (let ((mailbox (imap-utf7-encode mailbox)))
1881         (if (let ((cmd (concat "UID COPY " articles " \"" mailbox "\""))
1882                   (imap-current-target-mailbox mailbox))
1883               (if (imap-ok-p (imap-send-command-wait cmd))
1884                   t
1885                 (when (and (not dont-create)
1886                            ;; removed because of buggy Oracle server
1887                            ;; that doesn't send TRYCREATE tags (which
1888                            ;; is a MUST according to specifications):
1889                            ;;(imap-mailbox-get-1 'trycreate mailbox)
1890                            (imap-mailbox-create-1 mailbox))
1891                   (imap-ok-p (imap-send-command-wait cmd)))))
1892             (or no-copyuid
1893                 (imap-message-copyuid-1 mailbox)))))))
1894
1895 ;; FIXME: Amalgamate with imap-message-copyuid-1, using an extra arg, since it
1896 ;; shares most of the code?  -- fx
1897 (defun imap-message-appenduid-1 (mailbox)
1898   (if (imap-capability 'UIDPLUS)
1899       (imap-mailbox-get-1 'appenduid mailbox)
1900     (let ((old-mailbox imap-current-mailbox)
1901           (state imap-state)
1902           (imap-message-data (make-vector 2 0)))
1903       (when (imap-mailbox-examine-1 mailbox)
1904         (prog1
1905             (and (imap-fetch-safe '("*" . "*:*") "UID")
1906                  (list (imap-mailbox-get-1 'uidvalidity mailbox)
1907                        (apply 'max (imap-message-map
1908                                     (lambda (uid prop) uid) 'UID))))
1909           (if old-mailbox
1910               (imap-mailbox-select old-mailbox (eq state 'examine))
1911             (imap-mailbox-unselect)))))))
1912
1913 (defun imap-message-appenduid (mailbox &optional buffer)
1914   (with-current-buffer (or buffer (current-buffer))
1915     (imap-message-appenduid-1 (imap-utf7-encode mailbox))))
1916
1917 (defun imap-message-append (mailbox article &optional flags date-time buffer)
1918   "Append ARTICLE (a buffer) to MAILBOX on server in BUFFER.
1919 FLAGS and DATE-TIME is currently not used.  Return a cons holding
1920 uidvalidity of MAILBOX and UID the newly created article got, or nil
1921 on failure."
1922   (let ((mailbox (imap-utf7-encode mailbox)))
1923     (with-current-buffer (or buffer (current-buffer))
1924       (and (let ((imap-current-target-mailbox mailbox))
1925              (imap-ok-p
1926               (imap-send-command-wait
1927                (list "APPEND \"" mailbox "\" "  article))))
1928            (imap-message-appenduid-1 mailbox)))))
1929
1930 (defun imap-body-lines (body)
1931   "Return number of lines in article by looking at the mime bodystructure BODY."
1932   (if (listp body)
1933       (if (stringp (car body))
1934           (cond ((and (string= (upcase (car body)) "TEXT")
1935                       (numberp (nth 7 body)))
1936                  (nth 7 body))
1937                 ((and (string= (upcase (car body)) "MESSAGE")
1938                       (numberp (nth 9 body)))
1939                  (nth 9 body))
1940                 (t 0))
1941         (apply '+ (mapcar 'imap-body-lines body)))
1942     0))
1943
1944 (defun imap-envelope-from (from)
1945   "Return a from string line."
1946   (and from
1947        (concat (aref from 0)
1948                (if (aref from 0) " <")
1949                (aref from 2)
1950                "@"
1951                (aref from 3)
1952                (if (aref from 0) ">"))))
1953
1954 \f
1955 ;; Internal functions.
1956
1957 (defun imap-add-callback (tag func)
1958   (setq imap-callbacks (append (list (cons tag func)) imap-callbacks)))
1959
1960 (defun imap-send-command-1 (cmdstr)
1961   (setq cmdstr (concat cmdstr imap-client-eol))
1962   (and imap-log
1963        (with-current-buffer (get-buffer-create imap-log-buffer)
1964          (imap-disable-multibyte)
1965          (buffer-disable-undo)
1966          (goto-char (point-max))
1967          (insert cmdstr)))
1968   (process-send-string imap-process cmdstr))
1969
1970 (defun imap-send-command (command &optional buffer)
1971   (with-current-buffer (or buffer (current-buffer))
1972     (if (not (listp command)) (setq command (list command)))
1973     (let ((tag (setq imap-tag (1+ imap-tag)))
1974           cmd cmdstr)
1975       (setq cmdstr (concat (number-to-string imap-tag) " "))
1976       (while (setq cmd (pop command))
1977         (cond ((stringp cmd)
1978                (setq cmdstr (concat cmdstr cmd)))
1979               ((bufferp cmd)
1980                (let ((eol imap-client-eol)
1981                      (calcfirst imap-calculate-literal-size-first)
1982                      size)
1983                  (with-current-buffer cmd
1984                    (if calcfirst
1985                        (setq size (buffer-size)))
1986                    (when (not (equal eol "\r\n"))
1987                      ;; XXX modifies buffer!
1988                      (goto-char (point-min))
1989                      (while (search-forward "\r\n" nil t)
1990                        (replace-match eol)))
1991                    (if (not calcfirst)
1992                        (setq size (buffer-size))))
1993                  (setq cmdstr
1994                        (concat cmdstr (format "{%d}" size))))
1995                (unwind-protect
1996                    (progn
1997                      (imap-send-command-1 cmdstr)
1998                      (setq cmdstr nil)
1999                      (if (not (eq (imap-wait-for-tag tag) 'INCOMPLETE))
2000                          (setq command nil) ;; abort command if no cont-req
2001                        (let ((process imap-process)
2002                              (stream imap-stream)
2003                              (eol imap-client-eol))
2004                          (with-current-buffer cmd
2005                            (and imap-log
2006                                 (with-current-buffer (get-buffer-create
2007                                                       imap-log-buffer)
2008                                   (imap-disable-multibyte)
2009                                   (buffer-disable-undo)
2010                                   (goto-char (point-max))
2011                                   (insert-buffer-substring cmd)))
2012                            (process-send-region process (point-min)
2013                                                 (point-max)))
2014                          (process-send-string process imap-client-eol))))
2015                  (setq imap-continuation nil)))
2016               ((functionp cmd)
2017                (imap-send-command-1 cmdstr)
2018                (setq cmdstr nil)
2019                (unwind-protect
2020                    (setq command
2021                          (if (not (eq (imap-wait-for-tag tag) 'INCOMPLETE))
2022                              nil ;; abort command if no cont-req
2023                            (cons (funcall cmd imap-continuation)
2024                                  command)))
2025                  (setq imap-continuation nil)))
2026               (t
2027                (error "Unknown command type"))))
2028       (if cmdstr
2029           (imap-send-command-1 cmdstr))
2030       tag)))
2031
2032 (defun imap-wait-for-tag (tag &optional buffer)
2033   (with-current-buffer (or buffer (current-buffer))
2034     (let (imap-have-messaged)
2035       (while (and (null imap-continuation)
2036                   (memq (process-status imap-process) '(open run))
2037                   (< imap-reached-tag tag))
2038         (let ((len (/ (buffer-size) 1024))
2039               message-log-max)
2040           (unless (< len 10)
2041             (setq imap-have-messaged t)
2042             (message "imap read: %dk" len))
2043           (accept-process-output imap-process
2044                                  (truncate imap-read-timeout)
2045                                  (truncate (* (- imap-read-timeout
2046                                                  (truncate imap-read-timeout))
2047                                               1000)))))
2048       ;; A process can die _before_ we have processed everything it
2049       ;; has to say.  Moreover, this can happen in between the call to
2050       ;; accept-process-output and the call to process-status in an
2051       ;; iteration of the loop above.
2052       (when (and (null imap-continuation)
2053                  (< imap-reached-tag tag))
2054         (accept-process-output imap-process 0 0))
2055       (when imap-have-messaged
2056         (message ""))
2057       (and (memq (process-status imap-process) '(open run))
2058            (or (assq tag imap-failed-tags)
2059                (if imap-continuation
2060                    'INCOMPLETE
2061                  'OK))))))
2062
2063 (defun imap-sentinel (process string)
2064   (delete-process process))
2065
2066 (defun imap-find-next-line ()
2067   "Return point at end of current line, taking into account literals.
2068 Return nil if no complete line has arrived."
2069   (when (re-search-forward (concat imap-server-eol "\\|{\\([0-9]+\\)}"
2070                                    imap-server-eol)
2071                            nil t)
2072     (if (match-string 1)
2073         (if (< (point-max) (+ (point) (string-to-number (match-string 1))))
2074             nil
2075           (goto-char (+ (point) (string-to-number (match-string 1))))
2076           (imap-find-next-line))
2077       (point))))
2078
2079 (defun imap-arrival-filter (proc string)
2080   "IMAP process filter."
2081   ;; Sometimes, we are called even though the process has died.
2082   ;; Better abstain from doing stuff in that case.
2083   (when (buffer-name (process-buffer proc))
2084     (with-current-buffer (process-buffer proc)
2085       (goto-char (point-max))
2086       (insert string)
2087       (and imap-log
2088            (with-current-buffer (get-buffer-create imap-log-buffer)
2089              (imap-disable-multibyte)
2090              (buffer-disable-undo)
2091              (goto-char (point-max))
2092              (insert string)))
2093       (let (end)
2094         (goto-char (point-min))
2095         (while (setq end (imap-find-next-line))
2096           (save-restriction
2097             (narrow-to-region (point-min) end)
2098             (delete-backward-char (length imap-server-eol))
2099             (goto-char (point-min))
2100             (unwind-protect
2101                 (cond ((eq imap-state 'initial)
2102                        (imap-parse-greeting))
2103                       ((or (eq imap-state 'auth)
2104                            (eq imap-state 'nonauth)
2105                            (eq imap-state 'selected)
2106                            (eq imap-state 'examine))
2107                        (imap-parse-response))
2108                       (t
2109                        (message "Unknown state %s in arrival filter"
2110                                 imap-state)))
2111               (delete-region (point-min) (point-max)))))))))
2112
2113 \f
2114 ;; Imap parser.
2115
2116 (defsubst imap-forward ()
2117   (or (eobp) (forward-char)))
2118
2119 ;;   number          = 1*DIGIT
2120 ;;                       ; Unsigned 32-bit integer
2121 ;;                       ; (0 <= n < 4,294,967,296)
2122
2123 (defsubst imap-parse-number ()
2124   (when (looking-at "[0-9]+")
2125     (prog1
2126         (string-to-number (match-string 0))
2127       (goto-char (match-end 0)))))
2128
2129 ;;   literal         = "{" number "}" CRLF *CHAR8
2130 ;;                       ; Number represents the number of CHAR8s
2131
2132 (defsubst imap-parse-literal ()
2133   (when (looking-at "{\\([0-9]+\\)}\r\n")
2134     (let ((pos (match-end 0))
2135           (len (string-to-number (match-string 1))))
2136       (if (< (point-max) (+ pos len))
2137           nil
2138         (goto-char (+ pos len))
2139         (buffer-substring pos (+ pos len))))))
2140
2141 ;;   string          = quoted / literal
2142 ;;
2143 ;;   quoted          = DQUOTE *QUOTED-CHAR DQUOTE
2144 ;;
2145 ;;   QUOTED-CHAR     = <any TEXT-CHAR except quoted-specials> /
2146 ;;                     "\" quoted-specials
2147 ;;
2148 ;;   quoted-specials = DQUOTE / "\"
2149 ;;
2150 ;;   TEXT-CHAR       = <any CHAR except CR and LF>
2151
2152 (defsubst imap-parse-string ()
2153   (cond ((eq (char-after) ?\")
2154          (forward-char 1)
2155          (let ((p (point)) (name ""))
2156            (skip-chars-forward "^\"\\\\")
2157            (setq name (buffer-substring p (point)))
2158            (while (eq (char-after) ?\\)
2159              (setq p (1+ (point)))
2160              (forward-char 2)
2161              (skip-chars-forward "^\"\\\\")
2162              (setq name (concat name (buffer-substring p (point)))))
2163            (forward-char 1)
2164            name))
2165         ((eq (char-after) ?{)
2166          (imap-parse-literal))))
2167
2168 ;;   nil             = "NIL"
2169
2170 (defsubst imap-parse-nil ()
2171   (if (looking-at "NIL")
2172       (goto-char (match-end 0))))
2173
2174 ;;   nstring         = string / nil
2175
2176 (defsubst imap-parse-nstring ()
2177   (or (imap-parse-string)
2178       (and (imap-parse-nil)
2179            nil)))
2180
2181 ;;   astring         = atom / string
2182 ;;
2183 ;;   atom            = 1*ATOM-CHAR
2184 ;;
2185 ;;   ATOM-CHAR       = <any CHAR except atom-specials>
2186 ;;
2187 ;;   atom-specials   = "(" / ")" / "{" / SP / CTL / list-wildcards /
2188 ;;                     quoted-specials
2189 ;;
2190 ;;   list-wildcards  = "%" / "*"
2191 ;;
2192 ;;   quoted-specials = DQUOTE / "\"
2193
2194 (defsubst imap-parse-astring ()
2195   (or (imap-parse-string)
2196       (buffer-substring (point)
2197                         (if (re-search-forward "[(){ \r\n%*\"\\]" nil t)
2198                             (goto-char (1- (match-end 0)))
2199                           (end-of-line)
2200                           (point)))))
2201
2202 ;;   address         = "(" addr-name SP addr-adl SP addr-mailbox SP
2203 ;;                      addr-host ")"
2204 ;;
2205 ;;   addr-adl        = nstring
2206 ;;                       ; Holds route from [RFC-822] route-addr if
2207 ;;                       ; non-nil
2208 ;;
2209 ;;   addr-host       = nstring
2210 ;;                       ; nil indicates [RFC-822] group syntax.
2211 ;;                       ; Otherwise, holds [RFC-822] domain name
2212 ;;
2213 ;;   addr-mailbox    = nstring
2214 ;;                       ; nil indicates end of [RFC-822] group; if
2215 ;;                       ; non-nil and addr-host is nil, holds
2216 ;;                       ; [RFC-822] group name.
2217 ;;                       ; Otherwise, holds [RFC-822] local-part
2218 ;;                       ; after removing [RFC-822] quoting
2219 ;;
2220 ;;   addr-name       = nstring
2221 ;;                       ; If non-nil, holds phrase from [RFC-822]
2222 ;;                       ; mailbox after removing [RFC-822] quoting
2223 ;;
2224
2225 (defsubst imap-parse-address ()
2226   (let (address)
2227     (when (eq (char-after) ?\()
2228       (imap-forward)
2229       (setq address (vector (prog1 (imap-parse-nstring)
2230                               (imap-forward))
2231                             (prog1 (imap-parse-nstring)
2232                               (imap-forward))
2233                             (prog1 (imap-parse-nstring)
2234                               (imap-forward))
2235                             (imap-parse-nstring)))
2236       (when (eq (char-after) ?\))
2237         (imap-forward)
2238         address))))
2239
2240 ;;   address-list    = "(" 1*address ")" / nil
2241 ;;
2242 ;;   nil             = "NIL"
2243
2244 (defsubst imap-parse-address-list ()
2245   (if (eq (char-after) ?\()
2246       (let (address addresses)
2247         (imap-forward)
2248         (while (and (not (eq (char-after) ?\)))
2249                     ;; next line for MS Exchange bug
2250                     (progn (and (eq (char-after) ? ) (imap-forward)) t)
2251                     (setq address (imap-parse-address)))
2252           (setq addresses (cons address addresses)))
2253         (when (eq (char-after) ?\))
2254           (imap-forward)
2255           (nreverse addresses)))
2256     ;; With assert, the code might not be eval'd.
2257     ;; (assert (imap-parse-nil) t "In imap-parse-address-list")
2258     (imap-parse-nil)))
2259
2260 ;;   mailbox         = "INBOX" / astring
2261 ;;                       ; INBOX is case-insensitive.  All case variants of
2262 ;;                       ; INBOX (e.g. "iNbOx") MUST be interpreted as INBOX
2263 ;;                       ; not as an astring.  An astring which consists of
2264 ;;                       ; the case-insensitive sequence "I" "N" "B" "O" "X"
2265 ;;                       ; is considered to be INBOX and not an astring.
2266 ;;                       ;  Refer to section 5.1 for further
2267 ;;                       ; semantic details of mailbox names.
2268
2269 (defsubst imap-parse-mailbox ()
2270   (let ((mailbox (imap-parse-astring)))
2271     (if (string-equal "INBOX" (upcase mailbox))
2272         "INBOX"
2273       mailbox)))
2274
2275 ;;   greeting        = "*" SP (resp-cond-auth / resp-cond-bye) CRLF
2276 ;;
2277 ;;   resp-cond-auth  = ("OK" / "PREAUTH") SP resp-text
2278 ;;                       ; Authentication condition
2279 ;;
2280 ;;   resp-cond-bye   = "BYE" SP resp-text
2281
2282 (defun imap-parse-greeting ()
2283   "Parse an IMAP greeting."
2284   (cond ((looking-at "\\* OK ")
2285          (setq imap-state 'nonauth))
2286         ((looking-at "\\* PREAUTH ")
2287          (setq imap-state 'auth))
2288         ((looking-at "\\* BYE ")
2289          (setq imap-state 'closed))))
2290
2291 ;;   response        = *(continue-req / response-data) response-done
2292 ;;
2293 ;;   continue-req    = "+" SP (resp-text / base64) CRLF
2294 ;;
2295 ;;   response-data   = "*" SP (resp-cond-state / resp-cond-bye /
2296 ;;                     mailbox-data / message-data / capability-data) CRLF
2297 ;;
2298 ;;   response-done   = response-tagged / response-fatal
2299 ;;
2300 ;;   response-fatal  = "*" SP resp-cond-bye CRLF
2301 ;;                       ; Server closes connection immediately
2302 ;;
2303 ;;   response-tagged = tag SP resp-cond-state CRLF
2304 ;;
2305 ;;   resp-cond-state = ("OK" / "NO" / "BAD") SP resp-text
2306 ;;                       ; Status condition
2307 ;;
2308 ;;   resp-cond-bye   = "BYE" SP resp-text
2309 ;;
2310 ;;   mailbox-data    =  "FLAGS" SP flag-list /
2311 ;;                      "LIST" SP mailbox-list /
2312 ;;                      "LSUB" SP mailbox-list /
2313 ;;                      "SEARCH" *(SP nz-number) /
2314 ;;                      "STATUS" SP mailbox SP "("
2315 ;;                            [status-att SP number *(SP status-att SP number)] ")" /
2316 ;;                      number SP "EXISTS" /
2317 ;;                      number SP "RECENT"
2318 ;;
2319 ;;   message-data    = nz-number SP ("EXPUNGE" / ("FETCH" SP msg-att))
2320 ;;
2321 ;;   capability-data = "CAPABILITY" *(SP capability) SP "IMAP4rev1"
2322 ;;                     *(SP capability)
2323 ;;                       ; IMAP4rev1 servers which offer RFC 1730
2324 ;;                       ; compatibility MUST list "IMAP4" as the first
2325 ;;                       ; capability.
2326
2327 (defun imap-parse-response ()
2328   "Parse a IMAP command response."
2329   (let (token)
2330     (case (setq token (read (current-buffer)))
2331       (+ (setq imap-continuation
2332                (or (buffer-substring (min (point-max) (1+ (point)))
2333                                      (point-max))
2334                    t)))
2335       (* (case (prog1 (setq token (read (current-buffer)))
2336                  (imap-forward))
2337            (OK         (imap-parse-resp-text))
2338            (NO         (imap-parse-resp-text))
2339            (BAD        (imap-parse-resp-text))
2340            (BYE        (imap-parse-resp-text))
2341            (FLAGS      (imap-mailbox-put 'flags (imap-parse-flag-list)))
2342            (LIST       (imap-parse-data-list 'list))
2343            (LSUB       (imap-parse-data-list 'lsub))
2344            (SEARCH     (imap-mailbox-put
2345                         'search
2346                         (read (concat "(" (buffer-substring (point) (point-max)) ")"))))
2347            (STATUS     (imap-parse-status))
2348            (CAPABILITY (setq imap-capability
2349                                (read (concat "(" (upcase (buffer-substring
2350                                                           (point) (point-max)))
2351                                              ")"))))
2352            (ID         (setq imap-id (read (buffer-substring (point)
2353                                                              (point-max)))))
2354            (ACL        (imap-parse-acl))
2355            (t       (case (prog1 (read (current-buffer))
2356                             (imap-forward))
2357                       (EXISTS  (imap-mailbox-put 'exists token))
2358                       (RECENT  (imap-mailbox-put 'recent token))
2359                       (EXPUNGE t)
2360                       (FETCH   (imap-parse-fetch token))
2361                       (t       (message "Garbage: %s" (buffer-string)))))))
2362       (t (let (status)
2363            (if (not (integerp token))
2364                (message "Garbage: %s" (buffer-string))
2365              (case (prog1 (setq status (read (current-buffer)))
2366                      (imap-forward))
2367                (OK  (progn
2368                       (setq imap-reached-tag (max imap-reached-tag token))
2369                       (imap-parse-resp-text)))
2370                (NO  (progn
2371                       (setq imap-reached-tag (max imap-reached-tag token))
2372                       (save-excursion
2373                         (imap-parse-resp-text))
2374                       (let (code text)
2375                         (when (eq (char-after) ?\[)
2376                           (setq code (buffer-substring (point)
2377                                                        (search-forward "]")))
2378                           (imap-forward))
2379                         (setq text (buffer-substring (point) (point-max)))
2380                         (push (list token status code text)
2381                               imap-failed-tags))))
2382                (BAD (progn
2383                       (setq imap-reached-tag (max imap-reached-tag token))
2384                       (save-excursion
2385                         (imap-parse-resp-text))
2386                       (let (code text)
2387                         (when (eq (char-after) ?\[)
2388                           (setq code (buffer-substring (point)
2389                                                        (search-forward "]")))
2390                           (imap-forward))
2391                         (setq text (buffer-substring (point) (point-max)))
2392                         (push (list token status code text) imap-failed-tags)
2393                         (error "Internal error, tag %s status %s code %s text %s"
2394                                token status code text))))
2395                (t   (message "Garbage: %s" (buffer-string))))
2396              (when (assq token imap-callbacks)
2397                (funcall (cdr (assq token imap-callbacks)) token status)
2398                (setq imap-callbacks
2399                      (imap-remassoc token imap-callbacks)))))))))
2400
2401 ;;   resp-text       = ["[" resp-text-code "]" SP] text
2402 ;;
2403 ;;   text            = 1*TEXT-CHAR
2404 ;;
2405 ;;   TEXT-CHAR       = <any CHAR except CR and LF>
2406
2407 (defun imap-parse-resp-text ()
2408   (imap-parse-resp-text-code))
2409
2410 ;;   resp-text-code  = "ALERT" /
2411 ;;                     "BADCHARSET [SP "(" astring *(SP astring) ")" ] /
2412 ;;                     "NEWNAME" SP string SP string /
2413 ;;                     "PARSE" /
2414 ;;                     "PERMANENTFLAGS" SP "("
2415 ;;                               [flag-perm *(SP flag-perm)] ")" /
2416 ;;                     "READ-ONLY" /
2417 ;;                     "READ-WRITE" /
2418 ;;                     "TRYCREATE" /
2419 ;;                     "UIDNEXT" SP nz-number /
2420 ;;                     "UIDVALIDITY" SP nz-number /
2421 ;;                     "UNSEEN" SP nz-number /
2422 ;;                     resp-text-atom [SP 1*<any TEXT-CHAR except "]">]
2423 ;;
2424 ;;   resp_code_apnd  = "APPENDUID" SPACE nz_number SPACE uniqueid
2425 ;;
2426 ;;   resp_code_copy  = "COPYUID" SPACE nz_number SPACE set SPACE set
2427 ;;
2428 ;;   set             = sequence-num / (sequence-num ":" sequence-num) /
2429 ;;                        (set "," set)
2430 ;;                          ; Identifies a set of messages.  For message
2431 ;;                          ; sequence numbers, these are consecutive
2432 ;;                          ; numbers from 1 to the number of messages in
2433 ;;                          ; the mailbox
2434 ;;                          ; Comma delimits individual numbers, colon
2435 ;;                          ; delimits between two numbers inclusive.
2436 ;;                          ; Example: 2,4:7,9,12:* is 2,4,5,6,7,9,12,13,
2437 ;;                          ; 14,15 for a mailbox with 15 messages.
2438 ;;
2439 ;;   sequence-num    = nz-number / "*"
2440 ;;                          ; * is the largest number in use.  For message
2441 ;;                          ; sequence numbers, it is the number of messages
2442 ;;                          ; in the mailbox.  For unique identifiers, it is
2443 ;;                          ; the unique identifier of the last message in
2444 ;;                          ; the mailbox.
2445 ;;
2446 ;;   flag-perm       = flag / "\*"
2447 ;;
2448 ;;   flag            = "\Answered" / "\Flagged" / "\Deleted" /
2449 ;;                     "\Seen" / "\Draft" / flag-keyword / flag-extension
2450 ;;                       ; Does not include "\Recent"
2451 ;;
2452 ;;   flag-extension  = "\" atom
2453 ;;                       ; Future expansion.  Client implementations
2454 ;;                       ; MUST accept flag-extension flags.  Server
2455 ;;                       ; implementations MUST NOT generate
2456 ;;                       ; flag-extension flags except as defined by
2457 ;;                       ; future standard or standards-track
2458 ;;                       ; revisions of this specification.
2459 ;;
2460 ;;   flag-keyword    = atom
2461 ;;
2462 ;;   resp-text-atom  = 1*<any ATOM-CHAR except "]">
2463
2464 (defun imap-parse-resp-text-code ()
2465   ;; xxx next line for stalker communigate pro 3.3.1 bug
2466   (when (looking-at " \\[")
2467     (imap-forward))
2468   (when (eq (char-after) ?\[)
2469     (imap-forward)
2470     (cond ((search-forward "PERMANENTFLAGS " nil t)
2471            (imap-mailbox-put 'permanentflags (imap-parse-flag-list)))
2472           ((search-forward "UIDNEXT \\([0-9]+\\)" nil t)
2473            (imap-mailbox-put 'uidnext (match-string 1)))
2474           ((search-forward "UNSEEN " nil t)
2475            (imap-mailbox-put 'first-unseen (read (current-buffer))))
2476           ((looking-at "UIDVALIDITY \\([0-9]+\\)")
2477            (imap-mailbox-put 'uidvalidity (match-string 1)))
2478           ((search-forward "READ-ONLY" nil t)
2479            (imap-mailbox-put 'read-only t))
2480           ((search-forward "NEWNAME " nil t)
2481            (let (oldname newname)
2482              (setq oldname (imap-parse-string))
2483              (imap-forward)
2484              (setq newname (imap-parse-string))
2485              (imap-mailbox-put 'newname newname oldname)))
2486           ((search-forward "TRYCREATE" nil t)
2487            (imap-mailbox-put 'trycreate t imap-current-target-mailbox))
2488           ((looking-at "APPENDUID \\([0-9]+\\) \\([0-9]+\\)")
2489            (imap-mailbox-put 'appenduid
2490                              (list (match-string 1)
2491                                    (string-to-number (match-string 2)))
2492                              imap-current-target-mailbox))
2493           ((looking-at "COPYUID \\([0-9]+\\) \\([0-9,:]+\\) \\([0-9,:]+\\)")
2494            (imap-mailbox-put 'copyuid (list (match-string 1)
2495                                             (match-string 2)
2496                                             (match-string 3))
2497                              imap-current-target-mailbox))
2498           ((search-forward "ALERT] " nil t)
2499            (message "Imap server %s information: %s" imap-server
2500                     (buffer-substring (point) (point-max)))))))
2501
2502 ;;   mailbox-list    = "(" [mbx-list-flags] ")" SP
2503 ;;                      (DQUOTE QUOTED-CHAR DQUOTE / nil) SP mailbox
2504 ;;
2505 ;;   mbx-list-flags  = *(mbx-list-oflag SP) mbx-list-sflag
2506 ;;                     *(SP mbx-list-oflag) /
2507 ;;                     mbx-list-oflag *(SP mbx-list-oflag)
2508 ;;
2509 ;;   mbx-list-oflag  = "\Noinferiors" / flag-extension
2510 ;;                       ; Other flags; multiple possible per LIST response
2511 ;;
2512 ;;   mbx-list-sflag  = "\Noselect" / "\Marked" / "\Unmarked"
2513 ;;                       ; Selectability flags; only one per LIST response
2514 ;;
2515 ;;   QUOTED-CHAR     = <any TEXT-CHAR except quoted-specials> /
2516 ;;                     "\" quoted-specials
2517 ;;
2518 ;;   quoted-specials = DQUOTE / "\"
2519
2520 (defun imap-parse-data-list (type)
2521   (let (flags delimiter mailbox)
2522     (setq flags (imap-parse-flag-list))
2523     (when (looking-at " NIL\\| \"\\\\?\\(.\\)\"")
2524       (setq delimiter (match-string 1))
2525       (goto-char (1+ (match-end 0)))
2526       (when (setq mailbox (imap-parse-mailbox))
2527         (imap-mailbox-put type t mailbox)
2528         (imap-mailbox-put 'list-flags flags mailbox)
2529         (imap-mailbox-put 'delimiter delimiter mailbox)))))
2530
2531 ;;  msg_att         ::= "(" 1#("ENVELOPE" SPACE envelope /
2532 ;;                      "FLAGS" SPACE "(" #(flag / "\Recent") ")" /
2533 ;;                      "INTERNALDATE" SPACE date_time /
2534 ;;                      "RFC822" [".HEADER" / ".TEXT"] SPACE nstring /
2535 ;;                      "RFC822.SIZE" SPACE number /
2536 ;;                      "BODY" ["STRUCTURE"] SPACE body /
2537 ;;                      "BODY" section ["<" number ">"] SPACE nstring /
2538 ;;                      "UID" SPACE uniqueid) ")"
2539 ;;
2540 ;;  date_time       ::= <"> date_day_fixed "-" date_month "-" date_year
2541 ;;                      SPACE time SPACE zone <">
2542 ;;
2543 ;;  section         ::= "[" [section_text / (nz_number *["." nz_number]
2544 ;;                      ["." (section_text / "MIME")])] "]"
2545 ;;
2546 ;;  section_text    ::= "HEADER" / "HEADER.FIELDS" [".NOT"]
2547 ;;                      SPACE header_list / "TEXT"
2548 ;;
2549 ;;  header_fld_name ::= astring
2550 ;;
2551 ;;  header_list     ::= "(" 1#header_fld_name ")"
2552
2553 (defsubst imap-parse-header-list ()
2554   (when (eq (char-after) ?\()
2555     (let (strlist)
2556       (while (not (eq (char-after) ?\)))
2557         (imap-forward)
2558         (push (imap-parse-astring) strlist))
2559       (imap-forward)
2560       (nreverse strlist))))
2561
2562 (defsubst imap-parse-fetch-body-section ()
2563   (let ((section
2564          (buffer-substring (point) (1- (re-search-forward "[] ]" nil t)))))
2565     (if (eq (char-before) ? )
2566         (prog1
2567             (mapconcat 'identity (cons section (imap-parse-header-list)) " ")
2568           (search-forward "]" nil t))
2569       section)))
2570
2571 (defun imap-parse-fetch (response)
2572   (when (eq (char-after) ?\()
2573     (let (uid flags envelope internaldate rfc822 rfc822header rfc822text
2574               rfc822size body bodydetail bodystructure flags-empty)
2575       ;; Courier can insert spurious blank characters which will
2576       ;; confuse `read', so skip past them.
2577       (while (let ((moved (skip-chars-forward " \t")))
2578                (prog1 (not (eq (char-after) ?\)))
2579                  (unless (= moved 0) (backward-char))))
2580         (imap-forward)
2581         (let ((token (read (current-buffer))))
2582           (imap-forward)
2583           (cond ((eq token 'UID)
2584                  (setq uid (condition-case ()
2585                                (read (current-buffer))
2586                              (error))))
2587                 ((eq token 'FLAGS)
2588                  (setq flags (imap-parse-flag-list))
2589                  (if (not flags)
2590                      (setq flags-empty 't)))
2591                 ((eq token 'ENVELOPE)
2592                  (setq envelope (imap-parse-envelope)))
2593                 ((eq token 'INTERNALDATE)
2594                  (setq internaldate (imap-parse-string)))
2595                 ((eq token 'RFC822)
2596                  (setq rfc822 (imap-parse-nstring)))
2597                 ((eq token 'RFC822.HEADER)
2598                  (setq rfc822header (imap-parse-nstring)))
2599                 ((eq token 'RFC822.TEXT)
2600                  (setq rfc822text (imap-parse-nstring)))
2601                 ((eq token 'RFC822.SIZE)
2602                  (setq rfc822size (read (current-buffer))))
2603                 ((eq token 'BODY)
2604                  (if (eq (char-before) ?\[)
2605                      (push (list
2606                             (upcase (imap-parse-fetch-body-section))
2607                             (and (eq (char-after) ?<)
2608                                  (buffer-substring (1+ (point))
2609                                                    (search-forward ">" nil t)))
2610                             (progn (imap-forward)
2611                                    (imap-parse-nstring)))
2612                            bodydetail)
2613                    (setq body (imap-parse-body))))
2614                 ((eq token 'BODYSTRUCTURE)
2615                  (setq bodystructure (imap-parse-body))))))
2616       (when uid
2617         (setq imap-current-message uid)
2618         (imap-message-put uid 'UID uid)
2619         (and (or flags flags-empty) (imap-message-put uid 'FLAGS flags))
2620         (and envelope (imap-message-put uid 'ENVELOPE envelope))
2621         (and internaldate (imap-message-put uid 'INTERNALDATE internaldate))
2622         (and rfc822 (imap-message-put uid 'RFC822 rfc822))
2623         (and rfc822header (imap-message-put uid 'RFC822.HEADER rfc822header))
2624         (and rfc822text (imap-message-put uid 'RFC822.TEXT rfc822text))
2625         (and rfc822size (imap-message-put uid 'RFC822.SIZE rfc822size))
2626         (and body (imap-message-put uid 'BODY body))
2627         (and bodydetail (imap-message-put uid 'BODYDETAIL bodydetail))
2628         (and bodystructure (imap-message-put uid 'BODYSTRUCTURE bodystructure))
2629         (run-hooks 'imap-fetch-data-hook)))))
2630
2631 ;;   mailbox-data    =  ...
2632 ;;                      "STATUS" SP mailbox SP "("
2633 ;;                            [status-att SP number
2634 ;;                            *(SP status-att SP number)] ")"
2635 ;;                      ...
2636 ;;
2637 ;;   status-att      = "MESSAGES" / "RECENT" / "UIDNEXT" / "UIDVALIDITY" /
2638 ;;                     "UNSEEN"
2639
2640 (defun imap-parse-status ()
2641   (let ((mailbox (imap-parse-mailbox)))
2642     (if (eq (char-after) ? )
2643         (forward-char))
2644     (when (and mailbox (eq (char-after) ?\())
2645       (while (and (not (eq (char-after) ?\)))
2646                   (or (forward-char) t)
2647                   (looking-at "\\([A-Za-z]+\\) "))
2648         (let ((token (upcase (match-string 1))))
2649           (goto-char (match-end 0))
2650           (cond ((string= token "MESSAGES")
2651                  (imap-mailbox-put 'messages (read (current-buffer)) mailbox))
2652                 ((string= token "RECENT")
2653                  (imap-mailbox-put 'recent (read (current-buffer)) mailbox))
2654                 ((string= token "UIDNEXT")
2655                  (and (looking-at "[0-9]+")
2656                       (imap-mailbox-put 'uidnext (match-string 0) mailbox)
2657                       (goto-char (match-end 0))))
2658                 ((string= token "UIDVALIDITY")
2659                  (and (looking-at "[0-9]+")
2660                       (imap-mailbox-put 'uidvalidity (match-string 0) mailbox)
2661                       (goto-char (match-end 0))))
2662                 ((string= token "UNSEEN")
2663                  (imap-mailbox-put 'unseen (read (current-buffer)) mailbox))
2664                 (t
2665                  (message "Unknown status data %s in mailbox %s ignored"
2666                           token mailbox)
2667                  (read (current-buffer)))))))))
2668
2669 ;;   acl_data        ::= "ACL" SPACE mailbox *(SPACE identifier SPACE
2670 ;;                        rights)
2671 ;;
2672 ;;   identifier      ::= astring
2673 ;;
2674 ;;   rights          ::= astring
2675
2676 (defun imap-parse-acl ()
2677   (let ((mailbox (imap-parse-mailbox))
2678         identifier rights acl)
2679     (while (eq (char-after) ?\ )
2680       (imap-forward)
2681       (setq identifier (imap-parse-astring))
2682       (imap-forward)
2683       (setq rights (imap-parse-astring))
2684       (setq acl (append acl (list (cons identifier rights)))))
2685     (imap-mailbox-put 'acl acl mailbox)))
2686
2687 ;;   flag-list       = "(" [flag *(SP flag)] ")"
2688 ;;
2689 ;;   flag            = "\Answered" / "\Flagged" / "\Deleted" /
2690 ;;                     "\Seen" / "\Draft" / flag-keyword / flag-extension
2691 ;;                       ; Does not include "\Recent"
2692 ;;
2693 ;;   flag-keyword    = atom
2694 ;;
2695 ;;   flag-extension  = "\" atom
2696 ;;                       ; Future expansion.  Client implementations
2697 ;;                       ; MUST accept flag-extension flags.  Server
2698 ;;                       ; implementations MUST NOT generate
2699 ;;                       ; flag-extension flags except as defined by
2700 ;;                       ; future standard or standards-track
2701 ;;                       ; revisions of this specification.
2702
2703 (defun imap-parse-flag-list ()
2704   (let (flag-list start)
2705     (assert (eq (char-after) ?\() nil "In imap-parse-flag-list 1")
2706     (while (and (not (eq (char-after) ?\)))
2707                 (setq start (progn
2708                               (imap-forward)
2709                               ;; next line for Courier IMAP bug.
2710                               (skip-chars-forward " ")
2711                               (point)))
2712                 (> (skip-chars-forward "^ )" (point-at-eol)) 0))
2713       (push (buffer-substring start (point)) flag-list))
2714     (assert (eq (char-after) ?\)) nil "In imap-parse-flag-list 2")
2715     (imap-forward)
2716     (nreverse flag-list)))
2717
2718 ;;   envelope        = "(" env-date SP env-subject SP env-from SP env-sender SP
2719 ;;                     env-reply-to SP env-to SP env-cc SP env-bcc SP
2720 ;;                     env-in-reply-to SP env-message-id ")"
2721 ;;
2722 ;;   env-bcc         = "(" 1*address ")" / nil
2723 ;;
2724 ;;   env-cc          = "(" 1*address ")" / nil
2725 ;;
2726 ;;   env-date        = nstring
2727 ;;
2728 ;;   env-from        = "(" 1*address ")" / nil
2729 ;;
2730 ;;   env-in-reply-to = nstring
2731 ;;
2732 ;;   env-message-id  = nstring
2733 ;;
2734 ;;   env-reply-to    = "(" 1*address ")" / nil
2735 ;;
2736 ;;   env-sender      = "(" 1*address ")" / nil
2737 ;;
2738 ;;   env-subject     = nstring
2739 ;;
2740 ;;   env-to          = "(" 1*address ")" / nil
2741
2742 (defun imap-parse-envelope ()
2743   (when (eq (char-after) ?\()
2744     (imap-forward)
2745     (vector (prog1 (imap-parse-nstring) ;; date
2746               (imap-forward))
2747             (prog1 (imap-parse-nstring) ;; subject
2748               (imap-forward))
2749             (prog1 (imap-parse-address-list) ;; from
2750               (imap-forward))
2751             (prog1 (imap-parse-address-list) ;; sender
2752               (imap-forward))
2753             (prog1 (imap-parse-address-list) ;; reply-to
2754               (imap-forward))
2755             (prog1 (imap-parse-address-list) ;; to
2756               (imap-forward))
2757             (prog1 (imap-parse-address-list) ;; cc
2758               (imap-forward))
2759             (prog1 (imap-parse-address-list) ;; bcc
2760               (imap-forward))
2761             (prog1 (imap-parse-nstring) ;; in-reply-to
2762               (imap-forward))
2763             (prog1 (imap-parse-nstring) ;; message-id
2764               (imap-forward)))))
2765
2766 ;;   body-fld-param  = "(" string SP string *(SP string SP string) ")" / nil
2767
2768 (defsubst imap-parse-string-list ()
2769   (cond ((eq (char-after) ?\() ;; body-fld-param
2770          (let (strlist str)
2771            (imap-forward)
2772            (while (setq str (imap-parse-string))
2773              (push str strlist)
2774              ;; buggy stalker communigate pro 3.0 doesn't print SPC
2775              ;; between body-fld-param's sometimes
2776              (or (eq (char-after) ?\")
2777                  (imap-forward)))
2778            (nreverse strlist)))
2779         ((imap-parse-nil)
2780          nil)))
2781
2782 ;;   body-extension  = nstring / number /
2783 ;;                      "(" body-extension *(SP body-extension) ")"
2784 ;;                       ; Future expansion.  Client implementations
2785 ;;                       ; MUST accept body-extension fields.  Server
2786 ;;                       ; implementations MUST NOT generate
2787 ;;                       ; body-extension fields except as defined by
2788 ;;                       ; future standard or standards-track
2789 ;;                       ; revisions of this specification.
2790
2791 (defun imap-parse-body-extension ()
2792   (if (eq (char-after) ?\()
2793       (let (b-e)
2794         (imap-forward)
2795         (push (imap-parse-body-extension) b-e)
2796         (while (eq (char-after) ?\ )
2797           (imap-forward)
2798           (push (imap-parse-body-extension) b-e))
2799         (assert (eq (char-after) ?\)) nil "In imap-parse-body-extension")
2800         (imap-forward)
2801         (nreverse b-e))
2802     (or (imap-parse-number)
2803         (imap-parse-nstring))))
2804
2805 ;;   body-ext-1part  = body-fld-md5 [SP body-fld-dsp [SP body-fld-lang
2806 ;;                     *(SP body-extension)]]
2807 ;;                       ; MUST NOT be returned on non-extensible
2808 ;;                       ; "BODY" fetch
2809 ;;
2810 ;;   body-ext-mpart  = body-fld-param [SP body-fld-dsp [SP body-fld-lang
2811 ;;                     *(SP body-extension)]]
2812 ;;                       ; MUST NOT be returned on non-extensible
2813 ;;                       ; "BODY" fetch
2814
2815 (defsubst imap-parse-body-ext ()
2816   (let (ext)
2817     (when (eq (char-after) ?\ ) ;; body-fld-dsp
2818       (imap-forward)
2819       (let (dsp)
2820         (if (eq (char-after) ?\()
2821             (progn
2822               (imap-forward)
2823               (push (imap-parse-string) dsp)
2824               (imap-forward)
2825               (push (imap-parse-string-list) dsp)
2826               (imap-forward))
2827           ;; With assert, the code might not be eval'd.
2828           ;; (assert (imap-parse-nil) t "In imap-parse-body-ext")
2829           (imap-parse-nil))
2830         (push (nreverse dsp) ext))
2831       (when (eq (char-after) ?\ ) ;; body-fld-lang
2832         (imap-forward)
2833         (if (eq (char-after) ?\()
2834             (push (imap-parse-string-list) ext)
2835           (push (imap-parse-nstring) ext))
2836         (while (eq (char-after) ?\ ) ;; body-extension
2837           (imap-forward)
2838           (setq ext (append (imap-parse-body-extension) ext)))))
2839     ext))
2840
2841 ;;   body            = "(" body-type-1part / body-type-mpart ")"
2842 ;;
2843 ;;   body-ext-1part  = body-fld-md5 [SP body-fld-dsp [SP body-fld-lang
2844 ;;                     *(SP body-extension)]]
2845 ;;                       ; MUST NOT be returned on non-extensible
2846 ;;                       ; "BODY" fetch
2847 ;;
2848 ;;   body-ext-mpart  = body-fld-param [SP body-fld-dsp [SP body-fld-lang
2849 ;;                     *(SP body-extension)]]
2850 ;;                       ; MUST NOT be returned on non-extensible
2851 ;;                       ; "BODY" fetch
2852 ;;
2853 ;;   body-fields     = body-fld-param SP body-fld-id SP body-fld-desc SP
2854 ;;                     body-fld-enc SP body-fld-octets
2855 ;;
2856 ;;   body-fld-desc   = nstring
2857 ;;
2858 ;;   body-fld-dsp    = "(" string SP body-fld-param ")" / nil
2859 ;;
2860 ;;   body-fld-enc    = (DQUOTE ("7BIT" / "8BIT" / "BINARY" / "BASE64"/
2861 ;;                     "QUOTED-PRINTABLE") DQUOTE) / string
2862 ;;
2863 ;;   body-fld-id     = nstring
2864 ;;
2865 ;;   body-fld-lang   = nstring / "(" string *(SP string) ")"
2866 ;;
2867 ;;   body-fld-lines  = number
2868 ;;
2869 ;;   body-fld-md5    = nstring
2870 ;;
2871 ;;   body-fld-octets = number
2872 ;;
2873 ;;   body-fld-param  = "(" string SP string *(SP string SP string) ")" / nil
2874 ;;
2875 ;;   body-type-1part = (body-type-basic / body-type-msg / body-type-text)
2876 ;;                     [SP body-ext-1part]
2877 ;;
2878 ;;   body-type-basic = media-basic SP body-fields
2879 ;;                       ; MESSAGE subtype MUST NOT be "RFC822"
2880 ;;
2881 ;;   body-type-msg   = media-message SP body-fields SP envelope
2882 ;;                     SP body SP body-fld-lines
2883 ;;
2884 ;;   body-type-text  = media-text SP body-fields SP body-fld-lines
2885 ;;
2886 ;;   body-type-mpart = 1*body SP media-subtype
2887 ;;                     [SP body-ext-mpart]
2888 ;;
2889 ;;   media-basic     = ((DQUOTE ("APPLICATION" / "AUDIO" / "IMAGE" /
2890 ;;                     "MESSAGE" / "VIDEO") DQUOTE) / string) SP media-subtype
2891 ;;                       ; Defined in [MIME-IMT]
2892 ;;
2893 ;;   media-message   = DQUOTE "MESSAGE" DQUOTE SP DQUOTE "RFC822" DQUOTE
2894 ;;                      ; Defined in [MIME-IMT]
2895 ;;
2896 ;;   media-subtype   = string
2897 ;;                       ; Defined in [MIME-IMT]
2898 ;;
2899 ;;   media-text      = DQUOTE "TEXT" DQUOTE SP media-subtype
2900 ;;                       ; Defined in [MIME-IMT]
2901
2902 (defun imap-parse-body ()
2903   (let (body)
2904     (when (eq (char-after) ?\()
2905       (imap-forward)
2906       (if (eq (char-after) ?\()
2907           (let (subbody)
2908             (while (and (eq (char-after) ?\()
2909                         (setq subbody (imap-parse-body)))
2910               ;; buggy stalker communigate pro 3.0 inserts a SPC between
2911               ;; parts in multiparts
2912               (when (and (eq (char-after) ?\ )
2913                          (eq (char-after (1+ (point))) ?\())
2914                 (imap-forward))
2915               (push subbody body))
2916             (imap-forward)
2917             (push (imap-parse-string) body) ;; media-subtype
2918             (when (eq (char-after) ?\ ) ;; body-ext-mpart:
2919               (imap-forward)
2920               (if (eq (char-after) ?\() ;; body-fld-param
2921                   (push (imap-parse-string-list) body)
2922                 (push (and (imap-parse-nil) nil) body))
2923               (setq body
2924                     (append (imap-parse-body-ext) body))) ;; body-ext-...
2925             (assert (eq (char-after) ?\)) nil "In imap-parse-body")
2926             (imap-forward)
2927             (nreverse body))
2928
2929         (push (imap-parse-string) body) ;; media-type
2930         (imap-forward)
2931         (push (imap-parse-string) body) ;; media-subtype
2932         (imap-forward)
2933         ;; next line for Sun SIMS bug
2934         (and (eq (char-after) ? ) (imap-forward))
2935         (if (eq (char-after) ?\() ;; body-fld-param
2936             (push (imap-parse-string-list) body)
2937           (push (and (imap-parse-nil) nil) body))
2938         (imap-forward)
2939         (push (imap-parse-nstring) body) ;; body-fld-id
2940         (imap-forward)
2941         (push (imap-parse-nstring) body) ;; body-fld-desc
2942         (imap-forward)
2943         ;; Next `or' for Sun SIMS bug.  It regards body-fld-enc as a
2944         ;; nstring and returns nil instead of defaulting back to 7BIT
2945         ;; as the standard says.
2946         ;; Exchange (2007, at least) does this as well.
2947         (push (or (imap-parse-nstring) "7BIT") body) ;; body-fld-enc
2948         (imap-forward)
2949         ;; Exchange 2007 can return -1, contrary to the spec...
2950         (if (eq (char-after) ?-)
2951             (progn
2952               (skip-chars-forward "-0-9")
2953               (push nil body))
2954           (push (imap-parse-number) body)) ;; body-fld-octets
2955
2956         ;; Ok, we're done parsing the required parts, what comes now is one of
2957         ;; three things:
2958         ;;
2959         ;; envelope       (then we're parsing body-type-msg)
2960         ;; body-fld-lines (then we're parsing body-type-text)
2961         ;; body-ext-1part (then we're parsing body-type-basic)
2962         ;;
2963         ;; The problem is that the two first are in turn optionally followed
2964         ;; by the third.  So we parse the first two here (if there are any)...
2965
2966         (when (eq (char-after) ?\ )
2967           (imap-forward)
2968           (let (lines)
2969             (cond ((eq (char-after) ?\() ;; body-type-msg:
2970                    (push (imap-parse-envelope) body) ;; envelope
2971                    (imap-forward)
2972                    (push (imap-parse-body) body) ;; body
2973                    ;; buggy stalker communigate pro 3.0 doesn't print
2974                    ;; number of lines in message/rfc822 attachment
2975                    (if (eq (char-after) ?\))
2976                        (push 0 body)
2977                      (imap-forward)
2978                      (push (imap-parse-number) body))) ;; body-fld-lines
2979                   ((setq lines (imap-parse-number)) ;; body-type-text:
2980                    (push lines body)) ;; body-fld-lines
2981                   (t
2982                    (backward-char))))) ;; no match...
2983
2984         ;; ...and then parse the third one here...
2985
2986         (when (eq (char-after) ?\ ) ;; body-ext-1part:
2987           (imap-forward)
2988           (push (imap-parse-nstring) body) ;; body-fld-md5
2989           (setq body (append (imap-parse-body-ext) body))) ;; body-ext-1part..
2990
2991         (assert (eq (char-after) ?\)) nil "In imap-parse-body 2")
2992         (imap-forward)
2993         (nreverse body)))))
2994
2995 (when imap-debug                        ; (untrace-all)
2996   (require 'trace)
2997   (buffer-disable-undo (get-buffer-create imap-debug-buffer))
2998   (mapc (lambda (f) (trace-function-background f imap-debug-buffer))
2999         '(
3000           imap-utf7-encode
3001           imap-utf7-decode
3002           imap-error-text
3003           imap-kerberos4s-p
3004           imap-kerberos4-open
3005           imap-ssl-p
3006           imap-ssl-open
3007           imap-network-p
3008           imap-network-open
3009           imap-interactive-login
3010           imap-kerberos4a-p
3011           imap-kerberos4-auth
3012           imap-cram-md5-p
3013           imap-cram-md5-auth
3014           imap-login-p
3015           imap-login-auth
3016           imap-anonymous-p
3017           imap-anonymous-auth
3018           imap-open-1
3019           imap-open
3020           imap-opened
3021           imap-ping-server
3022           imap-authenticate
3023           imap-close
3024           imap-capability
3025           imap-namespace
3026           imap-send-command-wait
3027           imap-mailbox-put
3028           imap-mailbox-get
3029           imap-mailbox-map-1
3030           imap-mailbox-map
3031           imap-current-mailbox
3032           imap-current-mailbox-p-1
3033           imap-current-mailbox-p
3034           imap-mailbox-select-1
3035           imap-mailbox-select
3036           imap-mailbox-examine-1
3037           imap-mailbox-examine
3038           imap-mailbox-unselect
3039           imap-mailbox-expunge
3040           imap-mailbox-close
3041           imap-mailbox-create-1
3042           imap-mailbox-create
3043           imap-mailbox-delete
3044           imap-mailbox-rename
3045           imap-mailbox-lsub
3046           imap-mailbox-list
3047           imap-mailbox-subscribe
3048           imap-mailbox-unsubscribe
3049           imap-mailbox-status
3050           imap-mailbox-acl-get
3051           imap-mailbox-acl-set
3052           imap-mailbox-acl-delete
3053           imap-current-message
3054           imap-list-to-message-set
3055           imap-fetch-asynch
3056           imap-fetch
3057           imap-fetch-safe
3058           imap-message-put
3059           imap-message-get
3060           imap-message-map
3061           imap-search
3062           imap-message-flag-permanent-p
3063           imap-message-flags-set
3064           imap-message-flags-del
3065           imap-message-flags-add
3066           imap-message-copyuid-1
3067           imap-message-copyuid
3068           imap-message-copy
3069           imap-message-appenduid-1
3070           imap-message-appenduid
3071           imap-message-append
3072           imap-body-lines
3073           imap-envelope-from
3074           imap-send-command-1
3075           imap-send-command
3076           imap-wait-for-tag
3077           imap-sentinel
3078           imap-find-next-line
3079           imap-arrival-filter
3080           imap-parse-greeting
3081           imap-parse-response
3082           imap-parse-resp-text
3083           imap-parse-resp-text-code
3084           imap-parse-data-list
3085           imap-parse-fetch
3086           imap-parse-status
3087           imap-parse-acl
3088           imap-parse-flag-list
3089           imap-parse-envelope
3090           imap-parse-body-extension
3091           imap-parse-body
3092           )))
3093
3094 (provide 'imap)
3095
3096 ;; arch-tag: 27369ed6-33e4-482f-96f1-8bb906ba70f7
3097 ;;; imap.el ends here