;;; nnheader.el --- header access macros for Gnus and its backends
-;; Copyright (C) 1987,88,89,90,93,94,95 Free Software Foundation, Inc.
+;; Copyright (C) 1987,88,89,90,93,94,95,96 Free Software Foundation, Inc.
;; Author: Masanobu UMEDA <umerin@flab.flab.fujitsu.junet>
;; Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;; These macros may look very much like the ones in GNUS 4.1. They
+;; These macros may look very much like the ones in GNUS 4.1. They
;; are, in a way, but you should note that the indices they use have
-;; been changed from the internal GNUS format to the NOV format. Makes
-;; it possible to read headers from XOVER much faster.
+;; been changed from the internal GNUS format to the NOV format. The
+;; makes it possible to read headers from XOVER much faster.
;;
;; The format of a header is now:
;; [number subject from date id references chars lines xref]
;;; Code:
(require 'mail-utils)
-(require 'sendmail)
-(eval-when-compile (require 'cl))
(defvar nnheader-max-head-length 4096
"*Max length of the head of articles.")
-(defalias 'nntp-header-number 'mail-header-number)
+(defvar nnheader-head-chop-length 2048
+ "*Length of each read operation when trying to fetch HEAD headers.")
+
+(defvar nnheader-file-name-translation-alist nil
+ "*Alist that says how to translate characters in file names.
+For instance, if \":\" is illegal as a file character in file names
+on your system, you could say something like:
+
+\(setq nnheader-file-name-translation-alist '((?: . ?_)))")
+
+(eval-and-compile
+ (autoload 'nnmail-message-id "nnmail")
+ (autoload 'mail-position-on-field "sendmail")
+ (autoload 'message-remove-header "message")
+ (autoload 'cancel-function-timers "timers"))
+
+;;; Header access macros.
+
(defmacro mail-header-number (header)
"Return article number in HEADER."
- (` (aref (, header) 0)))
+ `(aref ,header 0))
-(defalias 'nntp-set-header-number 'mail-header-set-number)
(defmacro mail-header-set-number (header number)
"Set article number of HEADER to NUMBER."
- (` (aset (, header) 0 (, number))))
+ `(aset ,header 0 ,number))
-(defalias 'nntp-header-subject 'mail-header-subject)
(defmacro mail-header-subject (header)
"Return subject string in HEADER."
- (` (aref (, header) 1)))
+ `(aref ,header 1))
-(defalias 'nntp-set-header-subject 'mail-header-set-subject)
(defmacro mail-header-set-subject (header subject)
"Set article subject of HEADER to SUBJECT."
- (` (aset (, header) 1 (, subject))))
+ `(aset ,header 1 ,subject))
-(defalias 'nntp-header-from 'mail-header-from)
(defmacro mail-header-from (header)
"Return author string in HEADER."
- (` (aref (, header) 2)))
+ `(aref ,header 2))
-(defalias 'nntp-set-header-from 'mail-header-set-from)
(defmacro mail-header-set-from (header from)
"Set article author of HEADER to FROM."
- (` (aset (, header) 2 (, from))))
+ `(aset ,header 2 ,from))
-(defalias 'nntp-header-date 'mail-header-date)
(defmacro mail-header-date (header)
"Return date in HEADER."
- (` (aref (, header) 3)))
+ `(aref ,header 3))
-(defalias 'nntp-set-header-date 'mail-header-set-date)
(defmacro mail-header-set-date (header date)
"Set article date of HEADER to DATE."
- (` (aset (, header) 3 (, date))))
+ `(aset ,header 3 ,date))
-(defalias 'nntp-header-id 'mail-header-id)
+(defalias 'mail-header-message-id 'mail-header-id)
(defmacro mail-header-id (header)
"Return Id in HEADER."
- (` (aref (, header) 4)))
+ `(aref ,header 4))
-(defalias 'nntp-set-header-id 'mail-header-set-id)
+(defalias 'mail-header-set-message-id 'mail-header-set-id)
(defmacro mail-header-set-id (header id)
"Set article Id of HEADER to ID."
- (` (aset (, header) 4 (, id))))
+ `(aset ,header 4 ,id))
-(defalias 'nntp-header-references 'mail-header-references)
(defmacro mail-header-references (header)
"Return references in HEADER."
- (` (aref (, header) 5)))
+ `(aref ,header 5))
-(defalias 'nntp-set-header-references 'mail-header-set-references)
(defmacro mail-header-set-references (header ref)
"Set article references of HEADER to REF."
- (` (aset (, header) 5 (, ref))))
+ `(aset ,header 5 ,ref))
-(defalias 'nntp-header-chars 'mail-header-chars)
(defmacro mail-header-chars (header)
"Return number of chars of article in HEADER."
- (` (aref (, header) 6)))
+ `(aref ,header 6))
-(defalias 'nntp-set-header-chars 'mail-header-set-chars)
(defmacro mail-header-set-chars (header chars)
"Set number of chars in article of HEADER to CHARS."
- (` (aset (, header) 6 (, chars))))
+ `(aset ,header 6 ,chars))
-(defalias 'nntp-header-lines 'mail-header-lines)
(defmacro mail-header-lines (header)
"Return lines in HEADER."
- (` (aref (, header) 7)))
+ `(aref ,header 7))
-(defalias 'nntp-set-header-lines 'mail-header-set-lines)
(defmacro mail-header-set-lines (header lines)
"Set article lines of HEADER to LINES."
- (` (aset (, header) 7 (, lines))))
+ `(aset ,header 7 ,lines))
-(defalias 'nntp-header-xref 'mail-header-xref)
(defmacro mail-header-xref (header)
"Return xref string in HEADER."
- (` (aref (, header) 8)))
+ `(aref ,header 8))
-(defalias 'nntp-set-header-xref 'mail-header-set-xref)
(defmacro mail-header-set-xref (header xref)
"Set article xref of HEADER to xref."
- (` (aset (, header) 8 (, xref))))
+ `(aset ,header 8 ,xref))
+
+(defun make-mail-header (&optional init)
+ "Create a new mail header structure initialized with INIT."
+ (make-vector 9 init))
+(defun make-full-mail-header (&optional number subject from date id
+ references chars lines xref)
+ "Create a new mail header structure initialized with the parameters given."
+ (vector number subject from date id references chars lines xref))
+
+;; Parsing headers and NOV lines.
+
+(defsubst nnheader-header-value ()
+ (buffer-substring (match-end 0) (gnus-point-at-eol)))
+
+(defvar nnheader-newsgroup-none-id 1)
+
+(defun nnheader-parse-head (&optional naked)
+ (let ((case-fold-search t)
+ (cur (current-buffer))
+ (buffer-read-only nil)
+ in-reply-to lines p)
+ (goto-char (point-min))
+ (when naked
+ (insert "\n"))
+ ;; Search to the beginning of the next header. Error messages
+ ;; do not begin with 2 or 3.
+ (prog1
+ (when (or naked (re-search-forward "^[23][0-9]+ " nil t))
+ ;; This implementation of this function, with nine
+ ;; search-forwards instead of the one re-search-forward and
+ ;; a case (which basically was the old function) is actually
+ ;; about twice as fast, even though it looks messier. You
+ ;; can't have everything, I guess. Speed and elegance
+ ;; doesn't always go hand in hand.
+ (vector
+ ;; Number.
+ (if naked
+ (progn
+ (setq p (point-min))
+ 0)
+ (prog1
+ (read cur)
+ (end-of-line)
+ (setq p (point))
+ (narrow-to-region (point)
+ (or (and (search-forward "\n.\n" nil t)
+ (- (point) 2))
+ (point)))))
+ ;; Subject.
+ (progn
+ (goto-char p)
+ (if (search-forward "\nsubject: " nil t)
+ (nnheader-header-value) "(none)"))
+ ;; From.
+ (progn
+ (goto-char p)
+ (if (search-forward "\nfrom: " nil t)
+ (nnheader-header-value) "(nobody)"))
+ ;; Date.
+ (progn
+ (goto-char p)
+ (if (search-forward "\ndate: " nil t)
+ (nnheader-header-value) ""))
+ ;; Message-ID.
+ (progn
+ (goto-char p)
+ (if (search-forward "\nmessage-id: " nil t)
+ (nnheader-header-value)
+ ;; If there was no message-id, we just fake one to make
+ ;; subsequent routines simpler.
+ (concat "none+"
+ (int-to-string
+ (incf nnheader-newsgroup-none-id)))))
+ ;; References.
+ (progn
+ (goto-char p)
+ (if (search-forward "\nreferences: " nil t)
+ (nnheader-header-value)
+ ;; Get the references from the in-reply-to header if there
+ ;; were no references and the in-reply-to header looks
+ ;; promising.
+ (if (and (search-forward "\nin-reply-to: " nil t)
+ (setq in-reply-to (nnheader-header-value))
+ (string-match "<[^>]+>" in-reply-to))
+ (substring in-reply-to (match-beginning 0)
+ (match-end 0))
+ "")))
+ ;; Chars.
+ 0
+ ;; Lines.
+ (progn
+ (goto-char p)
+ (if (search-forward "\nlines: " nil t)
+ (if (numberp (setq lines (read cur)))
+ lines 0)
+ 0))
+ ;; Xref.
+ (progn
+ (goto-char p)
+ (and (search-forward "\nxref: " nil t)
+ (nnheader-header-value)))))
+ (when naked
+ (goto-char (point-min))
+ (delete-char 1)))))
+
+(defmacro nnheader-nov-skip-field ()
+ '(search-forward "\t" eol 'move))
+
+(defmacro nnheader-nov-field ()
+ '(buffer-substring (point) (if (nnheader-nov-skip-field) (1- (point)) eol)))
+
+(defmacro nnheader-nov-read-integer ()
+ '(prog1
+ (if (= (following-char) ?\t)
+ 0
+ (let ((num (ignore-errors (read (current-buffer)))))
+ (if (numberp num) num 0)))
+ (or (eobp) (forward-char 1))))
+
+(defvar nnheader-none-counter 0)
+
+(defun nnheader-parse-nov ()
+ (let ((eol (gnus-point-at-eol)))
+ (vector
+ (nnheader-nov-read-integer) ; number
+ (nnheader-nov-field) ; subject
+ (nnheader-nov-field) ; from
+ (nnheader-nov-field) ; date
+ (or (nnheader-nov-field)
+ (concat "none+"
+ (int-to-string
+ (incf nnheader-none-counter)))) ; id
+ (nnheader-nov-field) ; refs
+ (nnheader-nov-read-integer) ; chars
+ (nnheader-nov-read-integer) ; lines
+ (if (= (following-char) ?\n)
+ nil
+ (nnheader-nov-field)) ; misc
+ )))
+
+(defun nnheader-insert-nov (header)
+ (princ (mail-header-number header) (current-buffer))
+ (insert
+ "\t"
+ (or (mail-header-subject header) "(none)") "\t"
+ (or (mail-header-from header) "(nobody)") "\t"
+ (or (mail-header-date header) "") "\t"
+ (or (mail-header-id header)
+ (nnmail-message-id))
+ "\t"
+ (or (mail-header-references header) "") "\t")
+ (princ (or (mail-header-chars header) 0) (current-buffer))
+ (insert "\t")
+ (princ (or (mail-header-lines header) 0) (current-buffer))
+ (insert "\t")
+ (when (mail-header-xref header)
+ (insert "Xref: " (mail-header-xref header) "\t"))
+ (insert "\n"))
+
+(defun nnheader-insert-article-line (article)
+ (goto-char (point-min))
+ (insert "220 ")
+ (princ article (current-buffer))
+ (insert " Article retrieved.\n")
+ (search-forward "\n\n" nil 'move)
+ (delete-region (point) (point-max))
+ (forward-char -1)
+ (insert "."))
+
+(defun nnheader-nov-delete-outside-range (beg end)
+ "Delete all NOV lines that lie outside the BEG to END range."
+ ;; First we find the first wanted line.
+ (nnheader-find-nov-line beg)
+ (delete-region (point-min) (point))
+ ;; Then we find the last wanted line.
+ (when (nnheader-find-nov-line end)
+ (forward-line 1))
+ (delete-region (point) (point-max)))
+
+(defun nnheader-find-nov-line (article)
+ "Put point at the NOV line that start with ARTICLE.
+If ARTICLE doesn't exist, put point where that line
+would have been. The function will return non-nil if
+the line could be found."
+ ;; This function basically does a binary search.
+ (let ((max (point-max))
+ (min (goto-char (point-min)))
+ (cur (current-buffer))
+ (prev (point-min))
+ num found)
+ (while (not found)
+ (goto-char (/ (+ max min) 2))
+ (beginning-of-line)
+ (if (or (= (point) prev)
+ (eobp))
+ (setq found t)
+ (setq prev (point))
+ (cond ((> (setq num (read cur)) article)
+ (setq max (point)))
+ ((< num article)
+ (setq min (point)))
+ (t
+ (setq found 'yes)))))
+ ;; Now we may have found the article we're looking for, or we
+ ;; may be somewhere near it.
+ (when (and (not (eq found 'yes))
+ (not (eq num article)))
+ (setq found (point))
+ (while (and (< (point) max)
+ (or (not (numberp num))
+ (< num article)))
+ (forward-line 1)
+ (setq found (point))
+ (or (eobp)
+ (= (setq num (read cur)) article)))
+ (unless (eq num article)
+ (goto-char found)))
+ (beginning-of-line)
+ (eq num article)))
;; Various cruft the backends and Gnus need to communicate.
(defvar nntp-server-buffer nil)
-(defvar gnus-verbose-backends t
- "*If non-nil, Gnus backends will generate lots of comments.")
+(defvar gnus-verbose-backends 7
+ "*A number that says how talkative the Gnus backends should be.")
(defvar gnus-nov-is-evil nil
"If non-nil, Gnus backends will never output headers in the NOV format.")
(defvar news-reply-yank-from nil)
(defvar news-reply-yank-message-id nil)
-;; All backends use this function, so I moved it to this file.
+(defvar nnheader-callback-function nil)
(defun nnheader-init-server-buffer ()
+ "Initialize the Gnus-backend communication buffer."
(save-excursion
- (setq nntp-server-buffer (get-buffer-create " *nntpd*"))
+ (unless (gnus-buffer-live-p nntp-server-buffer)
+ (setq nntp-server-buffer (get-buffer-create " *nntpd*")))
(set-buffer nntp-server-buffer)
(buffer-disable-undo (current-buffer))
(erase-buffer)
(setq case-fold-search t) ;Should ignore case.
t))
-(defun nnheader-set-init-variables (server defs)
- (let ((s server)
- val)
- ;; First we set the server variables in the sequence required. We
- ;; use the definitions from the `defs' list where that is
- ;; possible.
- (while s
- (set (car (car s))
- (if (setq val (assq (car (car s)) defs))
- (nth 1 val)
- (nth 1 (car s))))
- (setq s (cdr s)))
- ;; The we go through the defs list and set any variables that were
- ;; not set in the first sweep.
- (while defs
- (if (not (assq (car (car defs)) server))
- (set (car (car defs))
- (if (and (symbolp (nth 1 (car defs)))
- (not (boundp (nth 1 (car defs)))))
- (nth 1 (car defs))
- (eval (nth 1 (car defs))))))
- (setq defs (cdr defs)))))
-
-(defun nnheader-save-variables (server)
- (let (out)
- (while server
- (setq out (cons (list (car (car server))
- (symbol-value (car (car server))))
- out))
- (setq server (cdr server)))
- (nreverse out)))
+;;; Various functions the backends use.
-(defun nnheader-restore-variables (state)
- (while state
- (set (car (car state)) (nth 1 (car state)))
- (setq state (cdr state))))
+(defun nnheader-file-error (file)
+ "Return a string that says what is wrong with FILE."
+ (format
+ (cond
+ ((not (file-exists-p file))
+ "%s does not exist")
+ ((file-directory-p file)
+ "%s is a directory")
+ ((not (file-readable-p file))
+ "%s is not readable"))
+ file))
-;; Read the head of an article.
(defun nnheader-insert-head (file)
- (if (eq nnheader-max-head-length t)
- ;; Just read the entire file.
- (nnheader-insert-file-contents-literally file)
- (let ((beg 0)
- (chop 1024))
+ "Insert the head of the article."
+ (when (file-exists-p file)
+ (if (eq nnheader-max-head-length t)
+ ;; Just read the entire file.
+ (nnheader-insert-file-contents-literally file)
;; Read 1K blocks until we find a separator.
- (while (and (eq chop (nth 1 (nnheader-insert-file-contents-literally
- file nil beg (setq beg (+ chop beg)))))
- (prog1 (not (search-backward "\n\n" nil t))
- (goto-char (point-max)))
- (or (null nnheader-max-head-length)
- (< beg nnheader-max-head-length)))))))
+ (let ((beg 0)
+ format-alist)
+ (while (and (eq nnheader-head-chop-length
+ (nth 1 (nnheader-insert-file-contents-literally
+ file nil beg
+ (incf beg nnheader-head-chop-length))))
+ (prog1 (not (search-forward "\n\n" nil t))
+ (goto-char (point-max)))
+ (or (null nnheader-max-head-length)
+ (< beg nnheader-max-head-length))))))
+ t))
(defun nnheader-article-p ()
+ "Say whether the current buffer looks like an article."
(goto-char (point-min))
(if (not (search-forward "\n\n" nil t))
nil
(goto-char (match-end 0)))
(prog1
(eobp)
- (widen))))
-
-;; Written by Erik Naggum <erik@naggum.no>.
-(defun nnheader-insert-file-contents-literally (filename &optional visit beg end replace)
- "Like `insert-file-contents', q.v., but only reads in the file.
-A buffer may be modified in several ways after reading into the buffer due
-to advanced Emacs features, such as file-name-handlers, format decoding,
-find-file-hooks, etc.
- This function ensures that none of these modifications will take place."
- (let ( ; (file-name-handler-alist nil)
- (format-alist nil)
- (after-insert-file-functions nil)
- (find-buffer-file-type-function
- (if (fboundp 'find-buffer-file-type)
- (symbol-function 'find-buffer-file-type)
- nil)))
- (unwind-protect
- (progn
- (fset 'find-buffer-file-type (lambda (filename) t))
- (insert-file-contents filename visit beg end replace))
- (if find-buffer-file-type-function
- (fset 'find-buffer-file-type find-buffer-file-type-function)
- (fmakunbound 'find-buffer-file-type)))))
-
-(defun nnheader-find-file-noselect (filename &optional nowarn rawfile)
- "Read file FILENAME into a buffer and return the buffer.
-If a buffer exists visiting FILENAME, return that one, but
-verify that the file has not changed since visited or saved.
-The buffer is not selected, just returned to the caller."
- (setq filename
- (abbreviate-file-name
- (expand-file-name filename)))
- (if (file-directory-p filename)
- (if find-file-run-dired
- (dired-noselect filename)
- (error "%s is a directory." filename))
- (let* ((buf (get-file-buffer filename))
- (truename (abbreviate-file-name (file-truename filename)))
- (number (nthcdr 10 (file-attributes truename)))
- ;; Find any buffer for a file which has same truename.
- (other (and (not buf)
- (if (fboundp 'find-buffer-visiting)
- (find-buffer-visiting filename)
- (get-file-buffer filename))))
- error)
- ;; Let user know if there is a buffer with the same truename.
- (if other
- (progn
- (or nowarn
- (string-equal filename (buffer-file-name other))
- (message "%s and %s are the same file"
- filename (buffer-file-name other)))
- ;; Optionally also find that buffer.
- (if (or (and (boundp 'find-file-existing-other-name)
- find-file-existing-other-name)
- find-file-visit-truename)
- (setq buf other))))
- (if buf
- (or nowarn
- (verify-visited-file-modtime buf)
- (cond ((not (file-exists-p filename))
- (error "File %s no longer exists!" filename))
- ((yes-or-no-p
- (if (string= (file-name-nondirectory filename)
- (buffer-name buf))
- (format
- (if (buffer-modified-p buf)
- "File %s changed on disk. Discard your edits? "
- "File %s changed on disk. Reread from disk? ")
- (file-name-nondirectory filename))
- (format
- (if (buffer-modified-p buf)
- "File %s changed on disk. Discard your edits in %s? "
- "File %s changed on disk. Reread from disk into %s? ")
- (file-name-nondirectory filename)
- (buffer-name buf))))
- (save-excursion
- (set-buffer buf)
- (revert-buffer t t)))))
- (save-excursion
-;;; The truename stuff makes this obsolete.
-;;; (let* ((link-name (car (file-attributes filename)))
-;;; (linked-buf (and (stringp link-name)
-;;; (get-file-buffer link-name))))
-;;; (if (bufferp linked-buf)
-;;; (message "Symbolic link to file in buffer %s"
-;;; (buffer-name linked-buf))))
- (setq buf (create-file-buffer filename))
- ;; (set-buffer-major-mode buf)
- (set-buffer buf)
- (erase-buffer)
- (if rawfile
- (condition-case ()
- (nnheader-insert-file-contents-literally filename t)
- (file-error
- ;; Unconditionally set error
- (setq error t)))
- (condition-case ()
- (insert-file-contents filename t)
- (file-error
- ;; Run find-file-not-found-hooks until one returns non-nil.
- (or t ; (run-hook-with-args-until-success 'find-file-not-found-hooks)
- ;; If they fail too, set error.
- (setq error t)))))
- ;; Find the file's truename, and maybe use that as visited name.
- (setq buffer-file-truename truename)
- (setq buffer-file-number number)
- ;; On VMS, we may want to remember which directory in a search list
- ;; the file was found in.
- (and (eq system-type 'vax-vms)
- (let (logical)
- (if (string-match ":" (file-name-directory filename))
- (setq logical (substring (file-name-directory filename)
- 0 (match-beginning 0))))
- (not (member logical find-file-not-true-dirname-list)))
- (setq buffer-file-name buffer-file-truename))
- (if find-file-visit-truename
- (setq buffer-file-name
- (setq filename
- (expand-file-name buffer-file-truename))))
- ;; Set buffer's default directory to that of the file.
- (setq default-directory (file-name-directory filename))
- ;; Turn off backup files for certain file names. Since
- ;; this is a permanent local, the major mode won't eliminate it.
- (and (not (funcall backup-enable-predicate buffer-file-name))
- (progn
- (make-local-variable 'backup-inhibited)
- (setq backup-inhibited t)))
- (if rawfile
- nil
- (after-find-file error (not nowarn)))))
- buf)))
+ (widen))))
(defun nnheader-insert-references (references message-id)
- (if (and (not references) (not message-id))
- () ; This is illegal, but not all articles have Message-IDs.
- ;; Fold long references line to follow&