;;; nnimap.el --- IMAP interface for Gnus
-;; Copyright (C) 2010-2011 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2012 Free Software Foundation, Inc.
;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
;; Simon Josefsson <simon@josefsson.org>
(unless (fboundp 'declare-function) (defmacro declare-function (&rest r))))
(eval-and-compile
- (require 'nnheader))
+ (require 'nnheader)
+ ;; In Emacs 24, `open-protocol-stream' is an autoloaded alias for
+ ;; `make-network-stream'.
+ (unless (fboundp 'open-protocol-stream)
+ (require 'proto-stream)))
(eval-when-compile
(require 'cl))
(require 'tls)
(require 'parse-time)
(require 'nnmail)
-(require 'proto-stream)
(autoload 'auth-source-forget+ "auth-source")
(autoload 'auth-source-search "auth-source")
(defvoo nnimap-address nil
"The address of the IMAP server.")
+(defvoo nnimap-user nil
+ "Username to use for authentication to the IMAP server.")
+
(defvoo nnimap-server-port nil
"The IMAP port used.
If nnimap-stream is `ssl', this will default to `imaps'. If not,
(defstruct nnimap
group process commands capabilities select-result newlinep server
- last-command-time greeting examined stream-type)
+ last-command-time greeting examined stream-type initial-resync)
(defvar nnimap-object nil)
nnmail-extra-headers))))
(deffoo nnimap-retrieve-headers (articles &optional group server fetch-old)
+ (when group
+ (setq group (nnimap-decode-gnus-group group)))
(with-current-buffer nntp-server-buffer
(erase-buffer)
(when (nnimap-possibly-change-group group server)
(let (article bytes lines size string)
(block nil
(while (not (eobp))
- (while (not (looking-at "^\\* [0-9]+ FETCH.*UID \\([0-9]+\\)"))
+ (while (not (looking-at "\\* [0-9]+ FETCH.+?UID \\([0-9]+\\)"))
(delete-region (point) (progn (forward-line 1) (point)))
(when (eobp)
(return)))
(let ((structure (ignore-errors
(read (current-buffer)))))
(while (and (consp structure)
- (not (stringp (car structure))))
+ (not (atom (car structure))))
(setq structure (car structure)))
- (setq lines (nth 7 structure))))
+ (setq lines (if (and
+ (stringp (car structure))
+ (equal (upcase (nth 0 structure)) "MESSAGE")
+ (equal (upcase (nth 1 structure)) "RFC822"))
+ (nth 9 structure)
+ (nth 7 structure)))))
(delete-region (line-beginning-position) (line-end-position))
(insert (format "211 %s Article retrieved." article))
(forward-line 1)
result))
(mapconcat #'identity (nreverse result) ",")))))
-(deffoo nnimap-open-server (server &optional defs)
+(deffoo nnimap-open-server (server &optional defs no-reconnect)
(if (nnimap-server-opened server)
t
(unless (assq 'nnimap-address defs)
(setq defs (append defs (list (list 'nnimap-address server)))))
(nnoo-change-server 'nnimap server defs)
- (or (nnimap-find-connection nntp-server-buffer)
- (nnimap-open-connection nntp-server-buffer))))
+ (if no-reconnect
+ (nnimap-find-connection nntp-server-buffer)
+ (or (nnimap-find-connection nntp-server-buffer)
+ (nnimap-open-connection nntp-server-buffer)))))
(defun nnimap-make-process-buffer (buffer)
(with-current-buffer
(gnus-add-buffer)
(set (make-local-variable 'after-change-functions) nil)
(set (make-local-variable 'nnimap-object)
- (make-nnimap :server (nnoo-current-server 'nnimap)))
+ (make-nnimap :server (nnoo-current-server 'nnimap)
+ :initial-resync 0))
(push (list buffer (current-buffer)) nnimap-connection-alist)
(push (current-buffer) nnimap-process-buffers)
(current-buffer)))
-(defun nnimap-credentials (address ports)
+(defun nnimap-credentials (address ports user)
(let* ((auth-source-creation-prompts
'((user . "IMAP user at %h: ")
(secret . "IMAP password for %u@%h: ")))
(found (nth 0 (auth-source-search :max 1
:host address
:port ports
+ :user user
:require '(:user :secret)
:create t))))
(if found
nil
stream)))
+(defun nnimap-map-port (port)
+ (if (equal port "imaps")
+ "993"
+ port))
+
(defun nnimap-open-connection-1 (buffer)
(unless nnimap-keepalive-timer
(setq nnimap-keepalive-timer (run-at-time (* 60 15) (* 60 15)
(with-current-buffer (nnimap-make-process-buffer buffer)
(let* ((coding-system-for-read 'binary)
(coding-system-for-write 'binary)
- (port nil)
(ports
(cond
((memq nnimap-stream '(network plain starttls))
(push nnimap-server-port ports))
(let* ((stream-list
(open-protocol-stream
- "*nnimap*" (current-buffer) nnimap-address (car ports)
+ "*nnimap*" (current-buffer) nnimap-address
+ (nnimap-map-port (car ports))
:type nnimap-stream
:return-list t
:shell-command nnimap-shell-program
:capability-command "1 CAPABILITY\r\n"
+ :end-of-command "\r\n"
:success " OK "
:starttls-function
(lambda (capabilities)
(stream-type (plist-get props :type)))
(when (and stream (not (memq (process-status stream) '(open run))))
(setq stream nil))
+
+ (when (and (fboundp 'set-network-process-option) ;; Not in XEmacs.
+ (fboundp 'process-type) ;; Emacs 22 doesn't provide it.
+ (eq (process-type stream) 'network))
+ ;; Use TCP-keepalive so that connections that pass through a NAT
+ ;; router don't hang when left idle.
+ (set-network-process-option stream :keepalive t))
+
(setf (nnimap-process nnimap-object) stream)
(setf (nnimap-stream-type nnimap-object) stream-type)
(if (not stream)
(progn
(nnheader-report 'nnimap "Unable to contact %s:%s via %s"
- nnimap-address port nnimap-stream)
+ nnimap-address (car ports) nnimap-stream)
'no-connect)
(gnus-set-process-query-on-exit-flag stream nil)
(if (not (gnus-string-match-p "[*.] \\(OK\\|PREAUTH\\)" greeting))
(list
nnimap-address
(nnoo-current-server 'nnimap)))
- ports))))
+ ports
+ nnimap-user))))
(setq nnimap-object nil)
(let ((nnimap-inhibit-logging t))
(setq login-result
(nnimap-login (car credentials) (cadr credentials))))
(if (car login-result)
(progn
- ;; Save the credentials if a save function exists
- ;; (such a function will only be passed if a new
- ;; token was created).
+ ;; Save the credentials if a save function exists
+ ;; (such a function will only be passed if a new
+ ;; token was created).
(when (functionp (nth 2 credentials))
(funcall (nth 2 credentials)))
;; See if CAPABILITY is set as part of login
nnimap-status-string)
(deffoo nnimap-request-article (article &optional group server to-buffer)
+ (when group
+ (setq group (nnimap-decode-gnus-group group)))
(with-current-buffer nntp-server-buffer
(let ((result (nnimap-possibly-change-group group server))
parts structure)
(nnimap-get-whole-article article))
(let ((buffer (current-buffer)))
(with-current-buffer (or to-buffer nntp-server-buffer)
- (erase-buffer)
- (insert-buffer-substring buffer)
- (nnheader-ms-strip-cr)
- (cons group article)))))))))
+ (nnheader-insert-buffer-substring buffer)
+ (nnheader-ms-strip-cr)))
+ (cons group article)))))))
(deffoo nnimap-request-head (article &optional group server to-buffer)
+ (when group
+ (setq group (nnimap-decode-gnus-group group)))
(when (nnimap-possibly-change-group group server)
(with-current-buffer (nnimap-buffer)
(when (stringp article)
(if (consp (caar structure))
(nnimap-insert-partial-structure (pop structure) parts t)
(let ((bit (pop structure)))
- (insert (format "Content-type: %s/%s"
- (downcase (nth 0 bit))
- (downcase (nth 1 bit))))
- (if (member "CHARSET" (nth 2 bit))
+ (insert (format "Content-type: %s/%s"
+ (downcase (nth 0 bit))
+ (downcase (nth 1 bit))))
+ (if (member-ignore-case "CHARSET" (nth 2 bit))
(insert (format
- "; charset=%S\n" (cadr (member "CHARSET" (nth 2 bit)))))
+ "; charset=%S\n"
+ (cadr (member-ignore-case "CHARSET" (nth 2 bit)))))
(insert "\n"))
(insert (format "Content-transfer-encoding: %s\n"
(nth 5 bit)))
(incf num)))
(nreverse parts)))
+(defun nnimap-decode-gnus-group (group)
+ (decode-coding-string group 'utf-8))
+
(deffoo nnimap-request-group (group &optional server dont-check info)
+ (setq group (nnimap-decode-gnus-group group))
(let ((result (nnimap-possibly-change-group
;; Don't SELECT the group if we're going to select it
;; later, anyway.
t))))
(deffoo nnimap-request-create-group (group &optional server args)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group nil server)
(with-current-buffer (nnimap-buffer)
(car (nnimap-command "CREATE %S" (utf7-encode group t))))))
(deffoo nnimap-request-delete-group (group &optional force server)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group nil server)
(with-current-buffer (nnimap-buffer)
(car (nnimap-command "DELETE %S" (utf7-encode group t))))))
(deffoo nnimap-request-rename-group (group new-name &optional server)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group nil server)
(with-current-buffer (nnimap-buffer)
(nnimap-unselect-group)
(nnimap-command "EXAMINE DOES.NOT.EXIST"))
(deffoo nnimap-request-expunge-group (group &optional server)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group group server)
(with-current-buffer (nnimap-buffer)
(car (nnimap-command "EXPUNGE")))))
(deffoo nnimap-request-move-article (article group server accept-form
&optional last internal-move-group)
+ (setq group (nnimap-decode-gnus-group group))
(with-temp-buffer
(mm-disable-multibyte)
(when (funcall (if internal-move-group
result)))))))
(deffoo nnimap-request-expire-articles (articles group &optional server force)
+ (setq group (nnimap-decode-gnus-group group))
(cond
((null articles)
nil)
(with-temp-buffer
(mm-disable-multibyte)
(when (nnimap-request-article article group server (current-buffer))
- (nnheader-message 7 "Expiring article %s:%d" group article)
(when (functionp target)
(setq target (funcall target group)))
- (when (and target
- (not (eq target 'delete)))
- (if (or (gnus-request-group target t)
- (gnus-request-create-group target))
- (nnmail-expiry-target-group target group)
- (setq target nil)))
+ (if (and target
+ (not (eq target 'delete)))
+ (if (or (gnus-request-group target t)
+ (gnus-request-create-group target))
+ (progn
+ (nnmail-expiry-target-group target group)
+ (nnheader-message 7 "Expiring article %s:%d to %s"
+ group article target))
+ (setq target nil))
+ (nnheader-message 7 "Expiring article %s:%d" group article))
(when target
(push article deleted-articles))))))))
;; Change back to the current group again.
(car (setq result (nnimap-parse-response))))
;; Select the last instance of the message in the group.
(and (setq article
- (car (last (assoc "SEARCH" (cdr result)))))
+ (car (last (cdr (assoc "SEARCH" (cdr result))))))
(string-to-number article))))))
(defun nnimap-delete-article (articles)
"delete this article now"))))))
(deffoo nnimap-request-scan (&optional group server)
+ (when group
+ (setq group (nnimap-decode-gnus-group group)))
(when (and (nnimap-possibly-change-group nil server)
nnimap-inbox
nnimap-split-methods)
(nnheader-message 7 "nnimap %s splitting mail..." server)
- (nnimap-split-incoming-mail)))
+ (nnimap-split-incoming-mail)
+ (nnheader-message 7 "nnimap %s splitting mail...done" server)))
(defun nnimap-marks-to-flags (marks)
(let (flags flag)
flags))
(deffoo nnimap-request-update-group-status (group status &optional server)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group nil server)
(let ((command (assoc
status
(nnimap-command "%s %S" (cadr command) (utf7-encode group t)))))))
(deffoo nnimap-request-set-mark (group actions &optional server)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group group server)
(let (sequence)
(with-current-buffer (nnimap-buffer)
((eq action 'set) ""))
(mapconcat #'identity flags " ")))))))
;; Wait for the last command to complete to avoid later
- ;; syncronisation problems with the stream.
+ ;; synchronization problems with the stream.
(when sequence
(nnimap-wait-for-response sequence))))))
(deffoo nnimap-request-accept-article (group &optional server last)
+ (setq group (nnimap-decode-gnus-group group))
(when (nnimap-possibly-change-group nil server)
(nnmail-check-syntax)
(let ((message-id (message-field-value "message-id"))
result))
(deffoo nnimap-request-replace-article (article group buffer)
+ (setq group (nnimap-decode-gnus-group group))
(let (group-art)
(when (and (nnimap-possibly-change-group group nil)
;; Put the article into the group.
(separator (read (current-buffer)))
(group (read (current-buffer))))
(unless (member '%NoSelect flags)
- (push (if (stringp group)
- group
- (format "%s" group))
+ (push (utf7-decode (if (stringp group)
+ group
+ (format "%s" group)) t)
groups))))
(nreverse groups)))
(nnimap-get-groups)))
(unless (assoc group nnimap-current-infos)
;; Insert dummy numbers here -- they don't matter.
- (insert (format "%S 0 1 y\n" group))))
+ (insert (format "%S 0 1 y\n" (utf7-encode group)))))
t)))
(deffoo nnimap-retrieve-group-data-early (server infos)
- (when (nnimap-possibly-change-group nil server)
+ (when (and (nnimap-possibly-change-group nil server)
+ infos)
(with-current-buffer (nnimap-buffer)
(erase-buffer)
(setf (nnimap-group nnimap-object) nil)
+ (setf (nnimap-initial-resync nnimap-object) 0)
(let ((qresyncp (nnimap-capability "QRESYNC"))
params groups sequences active uidvalidity modseq group)
;; Go through the infos and gather the data needed to know
;; what and how to request the data.
(dolist (info infos)
(setq params (gnus-info-params info)
- group (gnus-group-real-name (gnus-info-group info))
+ group (nnimap-decode-gnus-group
+ (gnus-group-real-name (gnus-info-group info)))
active (cdr (assq 'active params))
uidvalidity (cdr (assq 'uidvalidity params))
modseq (cdr (assq 'modseq params)))
'qresync
nil group 'qresync)
sequences)
- (let ((start
- (if (and active uidvalidity)
- ;; Fetch the last 100 flags.
- (max 1 (- (cdr active) 100))
- 1))
- (command
+ (let ((command
(if uidvalidity
"EXAMINE"
;; If we don't have a UIDVALIDITY, then this is
;; have to do a SELECT (which is slower than an
;; examine), but will tell us whether the group
;; is read-only or not.
- "SELECT")))
+ "SELECT"))
+ start)
+ (if (and active uidvalidity)
+ ;; Fetch the last 100 flags.
+ (setq start (max 1 (- (cdr active) 100)))
+ (setf (nnimap-initial-resync nnimap-object)
+ (1+ (nnimap-initial-resync nnimap-object)))
+ (setq start 1))
(push (list (nnimap-send-command "%s %S" command
(utf7-encode group t))
(nnimap-send-command "UID FETCH %d:* FLAGS" start)
(deffoo nnimap-finish-retrieve-group-infos (server infos sequences)
(when (and sequences
- (nnimap-possibly-change-group nil server))
+ (nnimap-possibly-change-group nil server t)
+ ;; Check that the process is still alive.
+ (get-buffer-process (nnimap-buffer))
+ (memq (process-status (get-buffer-process (nnimap-buffer)))
+ '(open run)))
(with-current-buffer (nnimap-buffer)
;; Wait for the final data to trickle in.
(when (nnimap-wait-for-response (if (eq (cadar sequences) 'qresync)
(active (gnus-active group)))
(when active
(insert (format "%S %d %d y\n"
- (gnus-group-real-name group)
+ (decode-coding-string
+ (gnus-group-real-name group) 'utf-8)
(cdr active)
(car active)))))))))))
(defun nnimap-update-infos (flags infos)
(dolist (info infos)
- (let* ((group (gnus-group-real-name (gnus-info-group info)))
+ (let* ((group (nnimap-decode-gnus-group
+ (gnus-group-real-name (gnus-info-group info))))
(marks (cdr (assoc group flags))))
(when marks
(nnimap-update-info info marks)))))
(cdr (assq 'uidvalidity (gnus-info-params info)))))
(and old-uidvalidity
(not (equal old-uidvalidity uidvalidity))
- (> start-article 1)))
+ (or (not start-article)
+ (> start-article 1))))
(gnus-group-remove-parameter info 'uidvalidity)
(gnus-group-remove-parameter info 'modseq))
;; We have the data needed to update.
(goto-char start)
(setq vanished
(and (eq flag-sequence 'qresync)
- (re-search-forward "^\\* VANISHED .* \\([0-9:,]+\\)"
+ (re-search-forward "^\\* VANISHED .*? \\([0-9:,]+\\)"
(or end (point-min)) t)
(match-string 1)))
(goto-char start)
(declare-function gnus-fetch-headers "gnus-sum"
(articles &optional limit force-new dependencies))
-(deffoo nnimap-request-thread (header)
- (let* ((id (mail-header-id header))
- (refs (split-string
- (or (mail-header-references header)
- "")))
- (cmd (let ((value
- (format
- "(OR HEADER REFERENCES %s HEADER Message-Id %s)"
- id id)))
- (dolist (refid refs value)
- (setq value (format
- "(OR (OR HEADER Message-Id %s HEADER REFERENCES %s) %s)"
- refid refid value)))))
- (result (with-current-buffer (nnimap-buffer)
- (nnimap-command "UID SEARCH %s" cmd))))
- (when result
- (gnus-fetch-headers
- (and (car result) (delete 0 (mapcar #'string-to-number
- (cdr (assoc "SEARCH" (cdr result))))))
- nil t))))
+(autoload 'nnir-search-thread "nnir")
-(defun nnimap-possibly-change-group (group server)
+(deffoo nnimap-request-thread (header &optional group server)
+ (when group
+ (setq group (nnimap-decode-gnus-group group)))
+ (if gnus-refer-thread-use-nnir
+ (nnir-search-thread header)
+ (when (nnimap-possibly-change-group group server)
+ (let* ((cmd (nnimap-make-thread-query header))
+ (result (with-current-buffer (nnimap-buffer)
+ (nnimap-command "UID SEARCH %s" cmd))))
+ (when result
+ (gnus-fetch-headers
+ (and (car result)
+ (delete 0 (mapcar #'string-to-number
+ (cdr (assoc "SEARCH" (cdr result))))))
+ nil t))))))
+
+(defun nnimap-possibly-change-group (group server &optional no-reconnect)
(let ((open-result t))
(when (and server
(not (nnimap-server-opened server)))
- (setq open-result (nnimap-open-server server)))
+ (setq open-result (nnimap-open-server server nil no-reconnect)))
(cond
((not open-result)
nil)
(looking-at "\\*"))))
(not (looking-at (format "%d .*\n" sequence)))))
(when messagep
- (nnheader-message 7 "nnimap read %dk" (/ (buffer-size) 1000)))
+ (nnheader-message-maybe
+ 7 "nnimap read %dk from %s%s" (/ (buffer-size) 1000)
+ nnimap-address
+ (if (not (zerop (nnimap-initial-resync nnimap-object)))
+ (format " (initial sync of %d groups; please wait)"
+ (nnimap-initial-resync nnimap-object))
+ "")))
(nnheader-accept-process-output process)
(goto-char (point-max)))
+ (setf (nnimap-initial-resync nnimap-object) 0)
openp)
(quit
(when debug-on-quit
(defun nnimap-split-incoming-mail ()
(with-current-buffer (nnimap-buffer)
(let ((nnimap-incoming-split-list nil)
- (nnmail-split-methods (if (eq nnimap-split-methods 'default)
- nnmail-split-methods
- nnimap-split-methods))
+ (nnmail-split-methods
+ (cond
+ ((eq nnimap-split-methods 'default)
+ nnmail-split-methods)
+ (nnimap-split-methods
+ nnimap-split-methods)
+ (nnimap-split-fancy
+ 'nnmail-split-fancy)))
(nnmail-split-fancy (or nnimap-split-fancy
nnmail-split-fancy))
(nnmail-inhibit-default-split-group t)
(let (article bytes)
(block nil
(while (not (eobp))
- (while (not (looking-at "^\\* [0-9]+ FETCH.*UID \\([0-9]+\\)"))
+ (while (not (looking-at "\\* [0-9]+ FETCH.+UID \\([0-9]+\\)"))
(delete-region (point) (progn (forward-line 1) (point)))
(when (eobp)
(return)))
group-art))
nnimap-incoming-split-list)))
+(defun nnimap-make-thread-query (header)
+ (let* ((id (mail-header-id header))
+ (refs (split-string
+ (or (mail-header-references header)
+ "")))
+ (value
+ (format
+ "(OR HEADER REFERENCES %S HEADER Message-Id %S)"
+ id id)))
+ (dolist (refid refs value)
+ (setq value (format
+ "(OR (OR HEADER Message-Id %S HEADER REFERENCES %S) %s)"
+ refid refid value)))))
+
+
(provide 'nnimap)
;;; nnimap.el ends here