(setq result (if raw (nth 3 elem)
(format "%s" (nth 3 elem)))))))
result))
-
+
(defun assistant-set-variable (node variable value)
(let ((variables (assistant-get-list node "variable"))
elem)
(setq elem (cadr elem))
(when (eq (intern variable) (car elem))
(setcar (nthcdr 3 elem) value)))))
-
+
(defun assistant-render-text (text node)
(unless (and text node)
- (gnus-error
- 5
+ (gnus-error
+ 5
"The assistant was asked to render invalid text or node data"))
(dolist (elem text)
(if (stringp elem)
(cadr type))
assistant-widgets))
(t
- (push
+ (push
(widget-create
'editable-field
:value-face 'assistant-field
(setq variable (cadr variable))
(let ((type (nth 1 variable))
(value (nth 3 variable)))
- (when
+ (when
(cond
((eq type :number)
(string-match "[^0-9]" value))
(setq applicable (cons elem applicable))))
;; return the first thing we can
-
+
(while (setq elem (pop applicable))
(push (cadr (cadr elem)) return))
(append (assistant-get-list node "variable")
variables)))
variables))
-
+
(defun assistant-eval (form)
(let ((bindings nil))
(dolist (variable (assistant-get-all-variables))
(setq variable (cadr variable))
- (push (list (car variable)
+ (push (list (car variable)
(if (eq (nth 3 variable) 'default)
nil
(if (listp (nth 3 variable))
(expand-file-name "auto-autoloads.el")
(expand-file-name "gnus-load.el")))
-(defvar dgnushack-cus-load-file
+(defvar dgnushack-cus-load-file
(if (featurep 'xemacs)
(expand-file-name "custom-load.el")
(expand-file-name "cus-load.el")))
(lsh (if (dns-get 'truncated-p spec) 1 0) -1)
(lsh (if (dns-get 'recursion-desired-p spec) 1 0) 0)))
(dns-write-bytes
- (cond
+ (cond
((eq (dns-get 'response-code spec) 'no-error) 0)
((eq (dns-get 'response-code spec) 'format-error) 1)
((eq (dns-get 'response-code spec) 'server-failure) 2)
(let* ((elems (cdr (assq type ecomplete-database)))
(match (regexp-quote match))
(candidates
- (sort
+ (sort
(loop for (key count time text) in elems
when (string-match match text)
collect (list count time text))
;;; 2) write the new authinfo.enc
;;; M-x encrypt-write-file-contents RET ~/.authinfo.enc
-;;; 3) verify the new authinfo is correct
+;;; 3) verify the new authinfo is correct
;;; (this will insert the contents in the current buffer)
;;; M-: (encrypt-insert-file-contents "~/.authinfo.enc")
(if outdata
(progn
(message "%s was decrypted with %s"
- file
+ file
(encrypt-message-method-and-cipher method cipher))
- (when erase
+ (when erase
(delete-region (point-min) (point-max)))
(insert outdata))
;; the decryption failed, alas
(if model
(let* ((method (nth 0 model))
(cipher (nth 1 model))
- (passphrase
+ (passphrase
(encrypt-get-passphrase-if-needed file method cipher))
(outdata
(cond
(gnus-error 5 "%s was NOT encrypted with %s"
file
(encrypt-message-method-and-cipher method cipher))))
- (gnus-error
- 1
+ (gnus-error
+ 1
"%s has no associated encryption model! See encrypt-file-alist."
file)))
"Read the passphrase for FILE, METHOD, CIPHER if necessary."
(when (not (eq method 'pgg))
(let ((password-key (encrypt-password-key file method cipher))
- (password-question
+ (password-question
(format "password for %s (file %s)? "
(encrypt-message-method-and-cipher method cipher)
- file)))
+ file)))
(if add
(password-read-and-add password-question password-key)
(password-read password-question password-key)))))
(defun encrypt-message-method-and-cipher (method cipher)
- (format "method %s%s"
+ (format "method %s%s"
(symbol-name method)
(if cipher (format " (cipher %s)" cipher) "")))
(defun encrypt-gpg-decode-buffer (passphrase cipher)
(encrypt-gpg-process-buffer passphrase cipher nil))
-(defun encrypt-gpg-process-buffer (passphrase
- cipher
+(defun encrypt-gpg-process-buffer (passphrase
+ cipher
&optional encode)
"With PASSPHRASE, use GPG to encode or decode the current buffer."
(let* ((program encrypt-gpg-path)
(input (buffer-substring-no-properties (point-min) (point-max)))
- (temp-maker (if (fboundp 'make-temp-file)
- 'make-temp-file
+ (temp-maker (if (fboundp 'make-temp-file)
+ 'make-temp-file
'make-temp-name))
(temp-file (funcall temp-maker encrypt-temp-prefix))
(default-enable-multibyte-characters nil)
"--passphrase-fd" "0"
"--no-tty"))
exit-status exit-data)
-
+
(when encode
(setq args
(append args
(while alist
(let ((entry (pop alist)))
(when (gnus-methods-equal-p gnus-command-method (gnus-info-method entry))
- (gnus-agent-flush-group (gnus-info-group entry)))))))
+ (gnus-agent-flush-group (gnus-info-group entry)))))))
(defun gnus-agent-flush-group (group)
"Flush the agent's index files such that the GROUP no longer
(gnus-agent-save-alist gnus-agent-read-agentview)))
alist))
((end-of-file file-error)
- ;; The agentview file is missing.
+ ;; The agentview file is missing.
(condition-case nil
;; If the agent directory exists, attempt to perform a brute-force
;; reconstruction of its contents.
(let* (alist
(file-name-coding-system nnmail-pathname-coding-system)
- (file-attributes (directory-files-and-attributes
+ (file-attributes (directory-files-and-attributes
(gnus-agent-article-name ""
gnus-agent-read-agentview) nil "^[0-9]+$" t)))
(while file-attributes
(gnus-message 7 "gnus-agent-expire: Loading overview...")
(nnheader-insert-file-contents nov-file)
(goto-char (point-min))
-
+
(let (p)
(while (< (setq p (point)) (point-max))
(condition-case nil
(while (setq file (pop files))
(setq attrs (file-attributes file))
(unless (nth 0 attrs)
- (incf size (float (nth 7 attrs)))))))
+ (incf size (float (nth 7 attrs)))))))
(setq gnus-cache-need-update-total-fetched-for t)
(gnus-cache-with-refreshed-group
group
(let* ((entry (or (gnus-gethash group gnus-cache-total-fetched-hashtb)
- (gnus-sethash group (make-list 2 0)
+ (gnus-sethash group (make-list 2 0)
gnus-cache-total-fetched-hashtb)))
(file-name-coding-system nnmail-pathname-coding-system)
- (size (or (nth 7 (file-attributes
+ (size (or (nth 7 (file-attributes
(or file
(gnus-cache-file-name group ".overview"))))
0)))
(if entry
(apply '+ entry)
(let ((gnus-cache-inhibit-update-total-fetched-for (not no-inhibit)))
- (+
+ (+
(gnus-cache-update-overview-total-fetched-for group nil)
(gnus-cache-update-file-total-fetched-for group nil)))))))
(setq method
(cdr (assoc 'viewer
(car (mailcap-mime-info mime-type
- 'all
+ 'all
'no-decode)))))))
(let ((view-command (mm-mailcap-command method file-name nil)))
(message "viewing via %s" view-command)
(not (eq charset 'ascii)))
(mm-decode-coding-region (point-min) (point-max) charset))
(call-process-region (point-min) (point-max)
- "w3m"
+ "w3m"
nil article-buffer nil
"-halfdump"
"-no-cookie"
(push (gnus-html-image-id url) urls)
(push "-o" urls)))))
(let ((process
- (apply 'start-process
+ (apply 'start-process
"images" nil "curl"
"-s" "--create-dirs"
"--location"
RANGE1 and RANGE2 have to be sorted over <."
(let* (out
(min1 (car range1))
- (max1 (if (numberp min1)
+ (max1 (if (numberp min1)
(if (numberp (cdr range1))
(prog1 (cdr range1)
(setq range1 nil)) min1)
(min2 (car range2))
(max2 (if (numberp min2)
(if (numberp (cdr range2))
- (prog1 (cdr range2)
- (setq range2 nil)) min2)
+ (prog1 (cdr range2)
+ (setq range2 nil)) min2)
(prog1 (cdr min2)
(setq min2 (car min2))))))
(setq range1 (cdr range1)
;;; gnus-registry.el --- article registry for Gnus
-;;; Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+;;; Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
;;; Free Software Foundation, Inc.
;; Author: Ted Zlatanov <tzz@lifelogs.com>
:version "22.1"
:group 'gnus)
-(defvar gnus-registry-hashtb (make-hash-table
+(defvar gnus-registry-hashtb (make-hash-table
:size 256
:test 'equal)
"*The article registry by Message ID.")
"List of registry marks and their options.
`gnus-registry-mark-article' will offer symbols from this list
-for completion.
+for completion.
Each entry must have a character to be useful for summary mode
line display and for keyboard shortcuts.
:group 'gnus-registry
:type 'symbol)
-(defcustom gnus-registry-unfollowed-groups
+(defcustom gnus-registry-unfollowed-groups
'("delayed$" "drafts$" "queue$" "INBOX$")
"List of groups that gnus-registry-split-fancy-with-parent won't return.
The group names are matched, they don't have to be fully
:group 'gnus-registry
:type '(repeat symbol))
-(defcustom gnus-registry-cache-file
- (nnheader-concat
- (or gnus-dribble-directory gnus-home-directory "~/")
+(defcustom gnus-registry-cache-file
+ (nnheader-concat
+ (or gnus-dribble-directory gnus-home-directory "~/")
".gnus.registry.eld")
"File where the Gnus registry will be stored."
:group 'gnus-registry
(if gnus-save-startup-file-via-temp-buffer
(let ((coding-system-for-write gnus-ding-file-coding-system)
(standard-output (current-buffer)))
- (gnus-gnus-to-quick-newsrc-format
+ (gnus-gnus-to-quick-newsrc-format
t "gnus registry startup file" 'gnus-registry-alist)
(gnus-registry-cache-whitespace file)
(save-buffer))
(unwind-protect
(progn
(gnus-with-output-to-file working-file
- (gnus-gnus-to-quick-newsrc-format
+ (gnus-gnus-to-quick-newsrc-format
t "gnus registry startup file" 'gnus-registry-alist))
;; These bindings will mislead the current buffer
(when gnus-registry-clean-empty
(gnus-registry-clean-empty-function))
;; now trim and clean text properties from the registry appropriately
- (setq gnus-registry-alist
+ (setq gnus-registry-alist
(gnus-registry-remove-alist-text-properties
(gnus-registry-trim
(gnus-hashtable-to-alist
(dolist (group (gnus-registry-fetch-groups key))
(when (gnus-parameter-registry-ignore group)
(gnus-message
- 10
+ 10
"gnus-registry: deleted ignored group %s from key %s"
group key)
(gnus-registry-delete-group key group)))
(gnus-registry-fetch-extra key 'label))
(incf count)
(gnus-registry-delete-id key))
-
+
(unless (stringp key)
- (gnus-message
- 10
- "gnus-registry key %s was not a string, removing"
+ (gnus-message
+ 10
+ "gnus-registry key %s was not a string, removing"
key)
(gnus-registry-delete-id key))))
-
+
gnus-registry-hashtb)
count))
(defun gnus-registry-trim (alist)
"Trim alist to size, using gnus-registry-max-entries.
Any entries with extra data (marks, currently) are left alone."
- (if (null gnus-registry-max-entries)
+ (if (null gnus-registry-max-entries)
alist ; just return the alist
;; else, when given max-entries, trim the alist
(let* ((timehash (make-hash-table
(push item precious-list)
(push item junk-list))))
- (sort
+ (sort
junk-list
(lambda (a b)
- (let ((t1 (or (cdr (gethash (car a) timehash))
+ (let ((t1 (or (cdr (gethash (car a) timehash))
'(0 0 0)))
- (t2 (or (cdr (gethash (car b) timehash))
+ (t2 (or (cdr (gethash (car b) timehash))
'(0 0 0))))
(time-less-p t1 t2))))
;; we use the return value of this setq, which is the trimmed alist
(setq alist (append precious-list
(nthcdr trim-length junk-list))))))
-
+
(defun gnus-registry-action (action data-header from &optional to method)
(let* ((id (mail-header-id data-header))
(subject (gnus-string-remove-all-properties
(gnus-registry-simplify-subject
(mail-header-subject data-header))))
- (sender (gnus-string-remove-all-properties
+ (sender (gnus-string-remove-all-properties
(mail-header-from data-header)))
(from (gnus-group-guess-full-name-from-command-method from))
(to (if to (gnus-group-guess-full-name-from-command-method to) nil))
(let* ((refstr (or (message-fetch-field "references") "")) ; guaranteed
(reply-to (message-fetch-field "in-reply-to")) ; may be nil
;; now, if reply-to is valid, append it to the References
- (refstr (if reply-to
+ (refstr (if reply-to
(concat refstr " " reply-to)
refstr))
;; these may not be used, but the code is cleaner having them up here
9
"%s is looking for matches for reference %s from [%s]"
log-agent reference refstr)
- (dolist (group (gnus-registry-fetch-groups
- reference
+ (dolist (group (gnus-registry-fetch-groups
+ reference
gnus-registry-max-track-groups))
(when (and group (gnus-registry-follow-group-p group))
(gnus-message
(push group found))))
;; filter the found groups and return them
;; the found groups are the full groups
- (setq found (gnus-registry-post-process-groups
+ (setq found (gnus-registry-post-process-groups
"references" refstr found found)))
-
+
;; else: there were no matches, now try the extra tracking by sender
((and (gnus-registry-track-sender-p)
sender
matches)
(when (and this-sender
(equal sender this-sender))
- (let ((groups (gnus-registry-fetch-groups
+ (let ((groups (gnus-registry-fetch-groups
key
gnus-registry-max-track-groups)))
(dolist (group groups)
gnus-registry-hashtb)
;; filter the found groups and return them
;; the found groups are NOT the full groups
- (setq found (gnus-registry-post-process-groups
+ (setq found (gnus-registry-post-process-groups
"sender" sender found found-full)))
-
+
;; else: there were no matches, now try the extra tracking by subject
((and (gnus-registry-track-subject-p)
subject
matches)
(when (and this-subject
(equal subject this-subject))
- (let ((groups (gnus-registry-fetch-groups
+ (let ((groups (gnus-registry-fetch-groups
key
gnus-registry-max-track-groups)))
(dolist (group groups)
gnus-registry-hashtb)
;; filter the found groups and return them
;; the found groups are NOT the full groups
- (setq found (gnus-registry-post-process-groups
+ (setq found (gnus-registry-post-process-groups
"subject" subject found found-full))))
;; after the (cond) we extract the actual value safely
(car-safe found)))
(lambda (a b)
(> (gethash a freq 0)
(gethash b freq 0)))))))))
-
+
(if gnus-registry-use-long-group-names
(dolist (group groups)
(let ((m1 (gnus-find-method-for-group group))
(unless (member gnus-newsgroup-name (gnus-registry-fetch-groups id))
(gnus-message 9 "Registry: Registering article %d with group %s"
article gnus-newsgroup-name)
- (gnus-registry-add-group
- id
+ (gnus-registry-add-group
+ id
gnus-newsgroup-name
(gnus-registry-fetch-simplified-message-subject-fast article)
(gnus-registry-fetch-sender-fast article)))))))
(shortcut (if remove (upcase shortcut) shortcut)))
(unintern function-name)
(eval
- `(defun
+ `(defun
;; function name
- ,(intern function-name)
+ ,(intern function-name)
;; parameter definition
(&rest articles)
;; documentation
- ,(format
+ ,(format
"%s the %s mark over process-marked ARTICLES."
(upcase-initials variant-name)
mark)
;; interactive definition
- (interactive
+ (interactive
(gnus-summary-work-articles current-prefix-arg))
;; actual code
;; now the user is asked if gnus-registry-install is 'ask
(when (gnus-registry-install-p)
- (gnus-registry-set-article-mark-internal
+ (gnus-registry-set-article-mark-internal
;; all this just to get the mark, I must be doing it wrong
(intern ,(symbol-name mark))
articles ,remove t)
(gnus-message
- 9
+ 9
"Applying mark %s to %d articles"
,(symbol-name mark) (length articles))
(dolist (article articles)
- (gnus-summary-update-article
+ (gnus-summary-update-article
article
(assoc article (gnus-data-list nil)))))))
(push (intern function-name) keys-plist)
- (push shortcut keys-plist)
+ (push shortcut keys-plist)
(push (vector (format "%s %s"
(upcase-initials variant-name)
(symbol-name mark))
(intern function-name) t)
gnus-registry-misc-menus)
(gnus-message
- 9
- "Defined mark handling function %s"
+ 9
+ "Defined mark handling function %s"
function-name))))))
(gnus-define-keys-1
'(gnus-registry-mark-map "M" gnus-summary-mark-map)
keys-plist)
(add-hook 'gnus-summary-menu-hook
(lambda ()
- (easy-menu-add-item
+ (easy-menu-add-item
gnus-summary-misc-menu
- nil
+ nil
(cons "Registry Marks" gnus-registry-misc-menus))))))
;;; use like this:
-;;; (defalias 'gnus-user-format-function-M
+;;; (defalias 'gnus-user-format-function-M
;;; 'gnus-registry-user-format-function-M)
(defun gnus-registry-user-format-function-M (headers)
(let* ((id (mail-header-message-id headers))
(marks (when id (gnus-registry-fetch-extra-marks id))))
(apply 'concat (mapcar (lambda(mark)
- (let ((c
+ (let ((c
(plist-get
- (cdr-safe
+ (cdr-safe
(assoc mark gnus-registry-marks))
:char)))
(if c
(defun gnus-registry-read-mark ()
"Read a mark name from the user with completion."
- (let ((mark (gnus-completing-read-with-default
+ (let ((mark (gnus-completing-read-with-default
(symbol-name gnus-registry-default-mark)
- "Label"
+ "Label"
(mapcar (lambda (x) ; completion list
(cons (symbol-name (car-safe x)) (car-safe x)))
gnus-registry-marks))))
(gnus-message 1 "%s mark %s with message ID %s, resulting in %S"
(if remove "Removing" "Adding")
mark id new-marks))
-
+
(apply 'gnus-registry-store-extra-marks ; set the extra marks
id ; for the message ID
new-marks)))))
"Put a specific entry in the extras field of the registry entry for id."
(let* ((extra (gnus-registry-fetch-extra id))
;; all the entries except the one for `key'
- (the-rest (gnus-assq-delete-all key (gnus-registry-fetch-extra id)))
+ (the-rest (gnus-assq-delete-all key (gnus-registry-fetch-extra id)))
(alist (if value
(gnus-registry-remove-alist-text-properties
(cons (cons key value)
(dolist (crumb trail)
(when (stringp crumb)
;; push the group name into the list
- (setq
+ (setq
groups
(cons
(if (or (not (stringp crumb)) gnus-registry-use-long-group-names)
(when gnus-select-method
(push (cons "native" gnus-select-method)
gnus-predefined-server-alist))
-
+
(if gnus-agent
(gnus-agentize))
(when user (setq imap-username user))
(when passwd (setq imap-password passwd))
(if imap-auth
- (and (setq imap-last-authenticator
+ (and (setq imap-last-authenticator
(assq imap-auth imap-authenticator-alist))
(funcall (nth 2 imap-last-authenticator) (current-buffer))
(setq imap-state 'auth))
;; 1) the auth-sources user and password override everything
;; 2) it avoids macros, so it's cleaner
;; 3) it falls through to the mail-sources and then default values
- (cond
+ (cond
((and
(eq keyword :user)
- (setq user-auth
+ (setq user-auth
(nth 0 (auth-source-user-or-password
'("login" "password")
;; this is "host" in auth-sources
(setq recipients (delq recip recipients))))))))
(setq recipients (message-prune-recipients recipients))
-
+
;; Build the header alist. Allow the user to be asked whether
;; or not to reply to all recipients in a wide reply.
(setq follow-to (list (cons 'To (cdr (pop recipients)))))
(defun message-prune-recipients (recipients)
(dolist (rule message-prune-recipient-rules)
(let ((match (car rule))
- dup-match
+ dup-match
address)
(dolist (recipient recipients)
(setq address (car recipient))
(defun mm-uu-yenc-extract ()
;; This might not be exactly correct, but we sure can't get the
;; binary data from the article buffer, since that's already in a
- ;; non-binary charset. So get it from the original article buffer.
+ ;; non-binary charset. So get it from the original article buffer.
(mm-make-handle (with-current-buffer gnus-original-article-buffer
(mm-uu-copy-to-buffer start-point end-point))
(list (or (and file-name
(defaults (or defaults '(nil)))
info)
(if (listp mode)
- (setq info
- (mapcar
- (lambda (mode-element)
+ (setq info
+ (mapcar
+ (lambda (mode-element)
(netrc-machine-user-or-password
mode-element
authinfo-list
(deffoo nnagent-request-set-mark (group action server)
(mm-with-unibyte-buffer
(insert "(gnus-agent-synchronize-group-flags \""
- group
+ group
"\" '")
(gnus-pp action)
(insert " \""
;; Assume that articles with smaller numbers than the first one
;; Agent knows are gone.
(setq first (caar gnus-agent-article-alist))
- (when first
+ (when first
(while (and arts (< (car arts) first))
(pop arts)))
(set-buffer nntp-server-buffer)
(while (re-search-backward "^X-Gnus-Newsgroup: " beg t)
(delete-region (point) (progn (forward-line 1) (point)))))
(when nnmail-cache-accepted-message-ids
- (nnmail-cache-insert (nnmail-fetch-field "message-id")
+ (nnmail-cache-insert (nnmail-fetch-field "message-id")
group
(nnmail-fetch-field "subject")
(nnmail-fetch-field "from")))
(insert-buffer-substring buf)
(when last
(when nnmail-cache-accepted-message-ids
- (nnmail-cache-insert (nnmail-fetch-field "message-id")
+ (nnmail-cache-insert (nnmail-fetch-field "message-id")
group
(nnmail-fetch-field "subject")
(nnmail-fetch-field "from")))
(head-end . "^\t")
(generate-head-function . nndoc-generate-clari-briefs-head)
(article-transform-function . nndoc-transform-clari-briefs))
-
+
(standard-digest
(first-article . ,(concat "^" (make-string 70 ?-) "\n *\n+"))
(article-begin . ,(concat "^\n" (make-string 30 ?-) "\n *\n+"))
'nnmh-request-group
(list group server dont-check)))
-(deffoo nndraft-request-move-article (article group server accept-form
+(deffoo nndraft-request-move-article (article group server accept-form
&optional last move-is-internal)
(nndraft-possibly-change-group group)
(let ((buf (get-buffer-create " *nndraft move*"))
(nnfolder-save-active nnfolder-group-alist nnfolder-active-file)
(gnus-sorted-difference articles (nreverse deleted-articles)))))
-(deffoo nnfolder-request-move-article (article group server accept-form
+(deffoo nnfolder-request-move-article (article group server accept-form
&optional last move-is-internal)
(save-excursion
(let ((buf (get-buffer-create " *nnfolder move*"))
(while (re-search-backward (concat "^" nnfolder-article-marker) nil t)
(delete-region (point) (progn (forward-line 1) (point))))
(when nnmail-cache-accepted-message-ids
- (nnmail-cache-insert (nnmail-fetch-field "message-id")
+ (nnmail-cache-insert (nnmail-fetch-field "message-id")
group
(nnmail-fetch-field "subject")
(nnmail-fetch-field "from")))
(setq novitem (funcall nnir-get-article-nov-override-function
artitem))
;; else, set novitem through nnheader-parse-nov/nnheader-parse-head
- (case (setq foo (gnus-retrieve-headers (list artno)
+ (case (setq foo (gnus-retrieve-headers (list artno)
artfullgroup nil))
(nov
(goto-char (point-min))
(mapcar
(lambda (arg) (- arg numcorr))
articles)))
- (setq rval
+ (setq rval
(if (eq nnmairix-backend 'nnimap)
(let ((gnus-nov-is-evil t))
(nnmairix-call-backend
(deffoo nnmh-close-group (group &optional server)
t)
-(deffoo nnmh-request-move-article (article group server accept-form
+(deffoo nnmh-request-move-article (article group server accept-form
&optional last move-is-internal)
(let ((buf (get-buffer-create " *nnmh move*"))
result)
(nnmh-possibly-change-directory group server)
(nnmail-check-syntax)
(when nnmail-cache-accepted-message-ids
- (nnmail-cache-insert (nnmail-fetch-field "message-id")
+ (nnmail-cache-insert (nnmail-fetch-field "message-id")
group
(nnmail-fetch-field "subject")
(nnmail-fetch-field "from")))
stdin and return responses to stdout.")
(defvar nntp-authinfo-rejected nil
-"A custom error condition used to report 'Authentication Rejected' errors.
-Condition handlers that match just this condition ensure that the nntp
+"A custom error condition used to report 'Authentication Rejected' errors.
+Condition handlers that match just this condition ensure that the nntp
backend doesn't catch this error.")
(put 'nntp-authinfo-rejected 'error-conditions '(error nntp-authinfo-rejected))
(put 'nntp-authinfo-rejected 'error-message "Authorization Rejected")
(and nntp-pre-command (push nntp-pre-command command))
(let ((process-connection-type nil)) ;See `nntp-open-via-rlogin-and-netcat'.
(apply 'start-process "nntpd" buffer command))))
-
+
(defun nntp-open-via-telnet-and-telnet (buffer)
"Open a connection to an nntp server through an intermediate host.
;; This library is a direct translation of the Samba release 2.2.0
;; implementation of Windows NT and LanManager compatible password
;; encryption.
-;;
+;;
;; Interface functions:
-;;
+;;
;; ntlm-build-auth-request
;; This will return a binary string, which should be used in the
;; base64 encoded form and it is the caller's responsibility to encode
;; (which will be a binary string) as the first argument and to
;; encode the returned string with base64. The second argument user
;; should be given in user@domain format.
-;;
+;;
;; ntlm-get-password-hashes
;;
;;
"*If non-nil, display the size of the message that is being fetched."
:version "22.1" ;; Oort Gnus
:type 'boolean
- :group 'pop3)
+ :group 'pop3)
(defvar pop3-timestamp nil
"Timestamp returned when initially connected to the POP server.
(/ (cdr (assoc n message-sizes))
1024.0))
(message "Retrieving message %d of %d from %s..."
- n message-count pop3-mailhost))
+ n message-count pop3-mailhost))
(pop3-retr process n crashbuf)
(save-excursion
(set-buffer crashbuf)
(pop3-quit process)
(error "POP server doesn't support starttls")))
process))
- (t
+ (t
(open-network-stream "POP" (current-buffer) mailhost port))))
(let ((response (pop3-read-response process t)))
(setq pop3-timestamp
(defun pop3-list (process &optional msg)
"If MSG is nil, return an alist of (MESSAGE-ID . SIZE) pairs.
Otherwise, return the size of the message-id MSG"
- (pop3-send-command process (if msg
+ (pop3-send-command process (if msg
(format "LIST %d" msg)
"LIST"))
(let ((response (pop3-read-response process t)))
(md5-binary
(concat
(encode-hex-string
- (md5-binary (concat (md5-binary
+ (md5-binary (concat (md5-binary
(concat username ":" realm ":" passphrase))
":" nonce ":" cnonce
- (if authzid
+ (if authzid
(concat ":" authzid)))))
":" nonce
":" (format "%08x" nonce-count) ":" cnonce ":" qop ":"
(defun sieve-sasl-auth (buffer mech)
"Login to server using the SASL MECH method."
(message "sieve: Authenticating using %s..." mech)
- (if (sieve-manage-interactive-login
+ (if (sieve-manage-interactive-login
buffer
(lambda (user passwd)
(let (client step tag data rsp)
"Report an article as spam by resending via email.
Reports is as ham when HAM is set."
(dolist (article articles)
- (gnus-message 6
+ (gnus-message 6
"Reporting %s article %d to <%s>..."
(if ham "ham" "spam")
article spam-report-resend-to)
(unless spam-report-resend-to
- (customize-set-variable
+ (customize-set-variable
spam-report-resend-to
(read-from-minibuffer "email address to resend SPAM/HAM to? ")))
;; This is ganked from the `gnus-summary-resend-message' function.
projects / gnus / commitdiff