-;;; elpher.el --- A friendly gopher client. -*- lexical-binding:t -*-
+;;; elpher.el --- A friendly gopher and gemini client -*- lexical-binding:t -*-
-;; Copyright (C) 2019 Tim Vaughan
+;; Copyright (C) 2019-2020 Tim Vaughan
-;; Author: Tim Vaughan <tgvaughan@gmail.com>
+;; Author: Tim Vaughan <plugd@thelambdalab.xyz>
;; Created: 11 April 2019
-;; Version: 2.2.0
+;; Version: 2.10.2
;; Keywords: comm gopher
-;; Homepage: https://github.com/tgvaughan/elpher
-;; Package-Requires: ((emacs "26"))
+;; Homepage: http://thelambdalab.xyz/elpher
+;; Package-Requires: ((emacs "26.2"))
;; This file is not part of GNU Emacs.
;;; Commentary:
-;; Elpher aims to provide a practical and friendly gopher client
-;; for GNU Emacs. It supports:
+;; Elpher aims to provide a practical and friendly gopher and gemini
+;; client for GNU Emacs. It supports:
;; - intuitive keyboard and mouse-driven browsing,
;; - out-of-the-box compatibility with evil-mode,
;; - pleasant and configurable colouring of Gopher directories,
;; - direct visualisation of image files,
;; - a simple bookmark management system,
-;; - connections using TLS encryption,
-;; - basic support for the fledgling Gemini protocol.
+;; - gopher connections using TLS encryption,
+;; - the fledgling Gemini protocol,
+;; - the greybeard Finger protocol.
;; To launch Elpher, simply use 'M-x elpher'. This will open a start
;; page containing information on key bindings and suggested starting
;; Full instructions can be found in the Elpher info manual.
;; Elpher is under active development. Any suggestions for
-;; improvements are welcome!
+;; improvements are welcome, and can be made on the official
+;; project page, gopher://thelambdalab.xyz/1/projects/elpher/.
;;; Code:
(require 'shr)
(require 'url-util)
(require 'subr-x)
+(require 'dns)
+(require 'ansi-color)
+(require 'nsm)
+(require 'gnutls)
;;; Global constants
;;
-(defconst elpher-version "2.2.0"
+(defconst elpher-version "2.10.2"
"Current version of elpher.")
(defconst elpher-margin-width 6
"Width of left-hand margin used when rendering indicies.")
(defconst elpher-type-map
- '(((gopher ?0) elpher-get-gopher-node elpher-render-text "txt" elpher-text)
- ((gopher ?1) elpher-get-gopher-node elpher-render-index "/" elpher-index)
- ((gopher ?4) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?5) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?7) elpher-get-gopher-query-node elpher-render-index "?" elpher-search)
- ((gopher ?9) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?g) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?p) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?I) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?d) elpher-get-gopher-node elpher-render-download "doc" elpher-binary)
- ((gopher ?P) elpher-get-gopher-node elpher-render-download "doc" elpher-binary)
- ((gopher ?s) elpher-get-gopher-node elpher-render-download "snd" elpher-binary)
- ((gopher ?h) elpher-get-gopher-node elpher-render-html "htm" elpher-html)
- (gemini elpher-get-gemini-node elpher-render-gemini "gem" elpher-gemini)
- (telnet elpher-get-telnet-node nil "tel" elpher-telnet)
- (other-url elpher-get-other-url-node nil "url" elpher-other-url)
- ((special bookmarks) elpher-get-bookmarks-node nil)
- ((special start) elpher-get-start-node nil))
+ '(((gopher ?0) elpher-get-gopher-page elpher-render-text "txt" elpher-text)
+ ((gopher ?1) elpher-get-gopher-page elpher-render-index "/" elpher-index)
+ ((gopher ?4) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?5) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?7) elpher-get-gopher-query-page elpher-render-index "?" elpher-search)
+ ((gopher ?9) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?g) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?p) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?I) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?d) elpher-get-gopher-page elpher-render-download "doc" elpher-binary)
+ ((gopher ?P) elpher-get-gopher-page elpher-render-download "doc" elpher-binary)
+ ((gopher ?s) elpher-get-gopher-page elpher-render-download "snd" elpher-binary)
+ ((gopher ?h) elpher-get-gopher-page elpher-render-html "htm" elpher-html)
+ (gemini elpher-get-gemini-page elpher-render-gemini "gem" elpher-gemini)
+ (finger elpher-get-finger-page elpher-render-text "txt" elpher-text)
+ (telnet elpher-get-telnet-page nil "tel" elpher-telnet)
+ (other-url elpher-get-other-url-page nil "url" elpher-other-url)
+ ((special bookmarks) elpher-get-bookmarks-page nil "/" elpher-index)
+ ((special start) elpher-get-start-page nil))
"Association list from types to getters, renderers, margin codes and index faces.")
;;
(defgroup elpher nil
- "A gopher client."
+ "A gopher and gemini client."
:group 'applications)
+;; General appearance and customizations
+
+(defcustom elpher-open-urls-with-eww nil
+ "If non-nil, open URL selectors using eww.
+Otherwise, use the system browser via the BROWSE-URL function."
+ :type '(boolean))
+
+(defcustom elpher-use-header t
+ "If non-nil, display current page information in buffer header."
+ :type '(boolean))
+
+(defcustom elpher-auto-disengage-TLS nil
+ "If non-nil, automatically disengage TLS following an unsuccessful connection.
+While enabling this may seem convenient, it is also potentially dangerous as it
+allows switching from an encrypted channel back to plain text without user input."
+ :type '(boolean))
+
+(defcustom elpher-connection-timeout 5
+ "Specifies the number of seconds to wait for a network connection to time out."
+ :type '(integer))
+
+(defcustom elpher-filter-ansi-from-text nil
+ "If non-nil, filter ANSI escape sequences from text.
+The default behaviour is to use the ansi-color package to interpret these
+sequences."
+ :type '(boolean))
+
+(defcustom elpher-certificate-directory
+ (file-name-as-directory (locate-user-emacs-file "elpher-certificates"))
+ "Specify the name of the directory where client certificates will be stored.
+These certificates may be used for establishing authenticated TLS connections."
+ :type '(directory))
+
+(defcustom elpher-openssl-command "openssl"
+ "The command used to launch openssl when generating TLS client certificates."
+ :type '(file))
+
+(defcustom elpher-gemini-TLS-cert-checks nil
+ "If non-nil, verify gemini server TLS certs using the default security level.
+Otherwise, certificate verification is disabled.
+
+This defaults to off because it is standard practice for Gemini servers
+to use self-signed certificates, meaning that most servers provide what
+EMACS considers to be an invalid certificate."
+ :type '(boolean))
+
+(defcustom elpher-gemini-max-fill-width 80
+ "Specify the maximum default width (in columns) of text/gemini documents.
+The actual width used is the minimum of this value and the window width at
+the time when the text is rendered."
+ :type '(integer))
+
+(defcustom elpher-gemini-link-string "→ "
+ "Specify the string used to indicate links when rendering gemini maps.
+May be empty."
+ :type '(string))
+
+(defcustom elpher-gemini-bullet-string "•"
+ "Specify the string used for bullets when rendering gemini maps."
+ :type '(string))
+
+(defcustom elpher-bookmarks-file (locate-user-emacs-file "elpher-bookmarks")
+ "Specify the name of the file where elpher bookmarks will be saved."
+ :type '(file))
+
+(defcustom elpher-ipv4-always nil
+ "If non-nil, elpher will always use IPv4 to establish network connections.
+This can be useful when browsing from a computer that supports IPv6, because
+some servers which do not support IPv6 can take a long time to time-out."
+ :type '(boolean))
+
;; Face customizations
+(defgroup elpher-faces nil
+ "Elpher face customizations."
+ :group 'elpher)
+
(defface elpher-index
'((t :inherit font-lock-keyword-face))
"Face used for directory type directory records.")
"Face used for html type directory records.")
(defface elpher-gemini
- '((t :inherit font-lock-regexp-grouping-backslash))
- "Face used for html type directory records.")
+ '((t :inherit font-lock-constant-face))
+ "Face used for Gemini type directory records.")
(defface elpher-other-url
'((t :inherit font-lock-comment-face))
'((t :inherit shadow))
"Face used for brackets around directory margin key.")
-;; Other customizations
+(defface elpher-gemini-heading1
+ '((t :inherit bold :height 1.8))
+ "Face used for gemini heading level 1.")
-(defcustom elpher-open-urls-with-eww nil
- "If non-nil, open URL selectors using eww.
-Otherwise, use the system browser via the BROWSE-URL function."
- :type '(boolean))
+(defface elpher-gemini-heading2
+ '((t :inherit bold :height 1.5))
+ "Face used for gemini heading level 2.")
-(defcustom elpher-buttonify-urls-in-directories t
- "If non-nil, turns URLs matched in directories into clickable buttons."
- :type '(boolean))
-
-(defcustom elpher-use-header t
- "If non-nil, display current node information in buffer header."
- :type '(boolean))
-
-(defcustom elpher-auto-disengage-TLS nil
- "If non-nil, automatically disengage TLS following an unsuccessful connection.
-While enabling this may seem convenient, it is also potentially dangerous as it
-allows switching from an encrypted channel back to plain text without user input."
- :type '(boolean))
+(defface elpher-gemini-heading3
+ '((t :inherit bold :height 1.2))
+ "Face used for gemini heading level 3.")
+(defface elpher-gemini-preformatted
+ '((t :inherit fixed-pitch))
+ "Face used for pre-formatted gemini text blocks.")
;;; Model
;;
;; Gemini defaults
(if (equal (url-filename url) "")
(setf (url-filename url) "/"))))
- url)
+ (elpher-remove-redundant-ports url))
(set-match-data data))))
+(defun elpher-remove-redundant-ports (address)
+ "Remove redundant port specifiers from ADDRESS.
+Here 'redundant' means that the specified port matches the default
+for that protocol, eg 70 for gopher."
+ (if (and (not (elpher-address-special-p address))
+ (eq (url-portspec address) ; (url-port) is too slow!
+ (pcase (url-type address)
+ ("gemini" 1965)
+ ((or "gopher" "gophers") 70)
+ ("finger" 79)
+ (_ -1))))
+ (setf (url-portspec address) nil))
+ address)
+
(defun elpher-make-gopher-address (type selector host port &optional tls)
"Create an ADDRESS object using gopher directory record attributes.
The basic attributes include: TYPE, SELECTOR, HOST and PORT.
If the optional attribute TLS is non-nil, the address will be marked as
requiring gopher-over-TLS."
(cond
+ ((equal type ?i) nil)
((and (equal type ?h)
(string-prefix-p "URL:" selector))
(elpher-address-from-url (elt (split-string selector "URL:") 1)))
selector)))))
(defun elpher-make-special-address (type)
- "Create an ADDRESS object corresponding to the given special page symbol TYPE."
+ "Create an ADDRESS object corresponding to the given special address symbol TYPE."
type)
(defun elpher-address-to-url (address)
"Get string representation of ADDRESS, or nil if ADDRESS is special."
- (if (not (elpher-address-special-p address))
- (url-encode-url (url-recreate-url address))
- nil))
+ (if (elpher-address-special-p address)
+ nil
+ (url-encode-url (url-recreate-url address))))
(defun elpher-address-type (address)
"Retrieve type of ADDRESS object.
'gemini)
((equal protocol "telnet")
'telnet)
+ ((equal protocol "finger")
+ 'finger)
(t 'other-url)))))
(defun elpher-address-protocol (address)
"Retrieve host from ADDRESS object."
(url-host address))
+(defun elpher-address-user (address)
+ "Retrieve user from ADDRESS object."
+ (url-user address))
+
(defun elpher-address-port (address)
- "Retrieve port from ADDRESS object."
+ "Retrieve port from ADDRESS object.
+If no address is defined, returns 0. (This is for compatibility with the URL library.)"
(if (symbolp address)
- nil)
- (if (> (url-port address) 0)
- (url-port address)
- (or (and (or (equal (url-type address) "gopher")
- (equal (url-type address) "gophers"))
- 70)
- (and (equal (url-type address) "gemini")
- 1965))))
+ 0
+ (url-port address)))
(defun elpher-address-special-p (address)
"Return non-nil if ADDRESS object is special (e.g. start page, bookmarks page)."
"Retrieve gopher selector from ADDRESS object."
(if (member (url-filename address) '("" "/"))
""
- (substring (url-filename address) 2)))
-
-;; Node
-
-(defun elpher-make-node (display-string address &optional parent)
- "Create a node in the page hierarchy.
-
-DISPLAY-STRING records the display string used for the page.
-
-ADDRESS specifies the address object of the page.
-
-The optional PARENT specifies the parent node in the hierarchy.
-This is set every time the node is visited, so while it forms
-an important part of the node data there is no need to set it
-initially."
- (list display-string address parent))
-
-(defun elpher-node-display-string (node)
- "Retrieve the display string of NODE."
- (elt node 0))
+ (url-unhex-string (substring (url-filename address) 2))))
-(defun elpher-node-address (node)
- "Retrieve the ADDRESS object of NODE."
- (elt node 1))
-
-(defun elpher-node-parent (node)
- "Retrieve the parent node of NODE."
- (elt node 2))
-
-(defun elpher-set-node-parent (node parent)
- "Set the parent node of NODE to be PARENT."
- (setcar (cdr (cdr node)) parent))
;; Cache
"Set the cursor position cache for ADDRESS to POS."
(puthash address pos elpher-pos-cache))
-;; Node graph traversal
-(defvar elpher-current-node nil)
+;; Page
+
+(defun elpher-make-page (display-string address)
+ "Create a page with DISPLAY-STRING and ADDRESS."
+ (list display-string address))
+
+(defun elpher-page-display-string (page)
+ "Retrieve the display string corresponding to PAGE."
+ (elt page 0))
-(defun elpher-visit-node (node &optional renderer preserve-parent)
- "Visit NODE using its own renderer or RENDERER, if non-nil.
-Additionally, set the parent of NODE to `elpher-current-node',
-unless PRESERVE-PARENT is non-nil."
+(defun elpher-page-address (page)
+ "Retrieve the address corresponding to PAGE."
+ (elt page 1))
+
+(defun elpher-page-set-address (page new-address)
+ "Set the address corresponding to PAGE to NEW-ADDRESS."
+ (setcar (cdr page) new-address))
+
+(defvar elpher-current-page nil) ; buffer local
+(defvar elpher-history nil) ; buffer local
+
+(defun elpher-visit-page (page &optional renderer no-history)
+ "Visit PAGE using its own renderer or RENDERER, if non-nil.
+Additionally, push PAGE onto the stack of previously-visited pages,
+unless NO-HISTORY is non-nil."
(elpher-save-pos)
(elpher-process-cleanup)
- (unless preserve-parent
- (if (and (elpher-node-parent elpher-current-node)
- (equal (elpher-node-address elpher-current-node)
- (elpher-node-address node)))
- (elpher-set-node-parent node (elpher-node-parent elpher-current-node))
- (elpher-set-node-parent node elpher-current-node)))
- (setq elpher-current-node node)
- (let* ((address (elpher-node-address node))
+ (unless (or no-history
+ (equal (elpher-page-address elpher-current-page)
+ (elpher-page-address page)))
+ (push elpher-current-page elpher-history))
+ (setq-local elpher-current-page page)
+ (let* ((address (elpher-page-address page))
(type (elpher-address-type address))
(type-record (cdr (assoc type elpher-type-map))))
(if type-record
(if renderer
renderer
(cadr type-record)))
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(pcase type
(`(gopher ,type-char)
(error "Unsupported gopher selector type '%c' for '%s'"
(error "Unsupported address type '%S' for '%s'"
other (elpher-address-to-url address)))))))
-(defun elpher-visit-parent-node ()
- "Visit the parent of the current node."
- (let ((parent-node (elpher-node-parent elpher-current-node)))
- (when parent-node
- (elpher-visit-node parent-node nil t))))
+(defun elpher-visit-previous-page ()
+ "Visit the previous page in the history."
+ (let ((previous-page (pop elpher-history)))
+ (if previous-page
+ (elpher-visit-page previous-page nil t)
+ (error "No previous page"))))
-(defun elpher-reload-current-node ()
- "Reload the current node, discarding any existing cached content."
- (elpher-cache-content (elpher-node-address elpher-current-node) nil)
- (elpher-visit-node elpher-current-node))
+(defun elpher-reload-current-page ()
+ "Reload the current page, discarding any existing cached content."
+ (elpher-cache-content (elpher-page-address elpher-current-page) nil)
+ (elpher-visit-page elpher-current-page))
(defun elpher-save-pos ()
- "Save the current position of point to the current node."
- (when elpher-current-node
- (elpher-cache-pos (elpher-node-address elpher-current-node) (point))))
+ "Save the current position of point to the current page."
+ (when elpher-current-page
+ (elpher-cache-pos (elpher-page-address elpher-current-page) (point))))
(defun elpher-restore-pos ()
- "Restore the position of point to that cached in the current node."
- (let ((pos (elpher-get-cached-pos (elpher-node-address elpher-current-node))))
+ "Restore the position of point to that cached in the current page."
+ (let ((pos (elpher-get-cached-pos (elpher-page-address elpher-current-page))))
(if pos
(goto-char pos)
(goto-char (point-min)))))
;;; Buffer preparation
;;
+(defvar elpher-buffer-name "*elpher*"
+ "The default name of the Elpher buffer.")
+
(defun elpher-update-header ()
- "If `elpher-use-header' is true, display current node info in window header."
+ "If `elpher-use-header' is true, display current page info in window header."
(if elpher-use-header
- (let* ((display-string (elpher-node-display-string elpher-current-node))
- (address (elpher-node-address elpher-current-node))
- (url-string (if (elpher-address-special-p address)
- ""
- (concat " - " (elpher-address-to-url address) ""))))
- (setq header-line-format (list display-string url-string)))))
+ (let* ((display-string (elpher-page-display-string elpher-current-page))
+ (address (elpher-page-address elpher-current-page))
+ (tls-string (if (and (not (elpher-address-special-p address))
+ (member (elpher-address-protocol address)
+ '("gophers" "gemini")))
+ " [TLS encryption]"
+ ""))
+ (header (concat display-string
+ (propertize tls-string 'face 'bold))))
+ (setq header-line-format header))))
(defmacro elpher-with-clean-buffer (&rest args)
"Evaluate ARGS with a clean *elpher* buffer as current."
- (list 'with-current-buffer "*elpher*"
- '(elpher-mode)
- (append (list 'let '((inhibit-read-only t))
- '(erase-buffer)
- '(elpher-update-header))
- args)))
+ `(with-current-buffer elpher-buffer-name
+ (unless (eq major-mode 'elpher-mode)
+ ;; avoid resetting buffer-local variables
+ (elpher-mode))
+ (let ((inhibit-read-only t))
+ (setq-local network-security-level
+ (default-value 'network-security-level))
+ (erase-buffer)
+ (elpher-update-header)
+ ,@args)))
+
+(defun elpher-buffer-message (string &optional line)
+ "Replace first line in elpher buffer with STRING.
+If LINE is non-nil, replace that line instead."
+ (with-current-buffer elpher-buffer-name
+ (let ((inhibit-read-only t))
+ (goto-char (point-min))
+ (if line
+ (forward-line line))
+ (let ((data (match-data)))
+ (unwind-protect
+ (progn
+ (re-search-forward "^.*$")
+ (replace-match string))
+ (set-match-data data))))))
;;; Text Processing
;;
(defun elpher-network-error (address error)
- "Display ERROR message following unsuccessful negotiation with ADDRESS."
+ "Display ERROR message following unsuccessful negotiation with ADDRESS.
+ERROR can be either an error object or a string."
(elpher-with-clean-buffer
(insert (propertize "\n---- ERROR -----\n\n" 'face 'error)
"When attempting to retrieve " (elpher-address-to-url address) ":\n"
- (error-message-string error) ".\n"
+ (if (stringp error) error (error-message-string error)) "\n"
(propertize "\n----------------\n\n" 'face 'error)
"Press 'u' to return to the previous page.")))
-;;; Gopher selector retrieval
+;;; General network communication
;;
-(defun elpher-process-cleanup ()
- "Immediately shut down any extant elpher process."
- (let ((p (get-process "elpher-process")))
- (if p (delete-process p))))
+(defvar elpher-network-timer nil
+ "Timer used for network connections.")
(defvar elpher-use-tls nil
"If non-nil, use TLS to communicate with gopher servers.")
-(defvar elpher-selector-string)
+(defvar elpher-client-certificate nil
+ "If non-nil, contains client certificate details to use for TLS connections.")
-(defun elpher-get-selector (address after &optional propagate-error)
- "Retrieve selector specified by ADDRESS, then execute AFTER.
-The result is stored as a string in the variable ‘elpher-selector-string’.
+(defun elpher-process-cleanup ()
+ "Immediately shut down any extant elpher process and timers."
+ (let ((p (get-process "elpher-process")))
+ (if p (delete-process p)))
+ (if (timerp elpher-network-timer)
+ (cancel-timer elpher-network-timer)))
+
+(defun elpher-get-host-response (address default-port query-string response-processor
+ &optional use-tls force-ipv4)
+ "Generic function for retrieving data from ADDRESS.
+
+When ADDRESS lacks a specific port, DEFAULT-PORT is used instead.
+QUERY-STRING is a string sent to the host specified by ADDRESS to
+illicet a response. This response is passed as an argument to the
+function RESPONSE-PROCESSOR.
+
+If non-nil, USE-TLS specifies that the connection is to be made over
+TLS. If set to gemini, the certificate verification will be disabled
+unless `elpher-gemini-TLS-cert-checks' is non-nil.
+
+If non-nil, FORCE-IPV4 causes the network connection to be made over
+ipv4 only. (The default behaviour when this is not set depends on
+the host operating system and the local network capabilities."
+ (if (and use-tls (not (gnutls-available-p)))
+ (error "Use of TLS requires Emacs to be compiled with GNU TLS support")
+ (unless (< (elpher-address-port address) 65536)
+ (error "Cannot establish network connection: port number > 65536"))
+ (when (and (eq use-tls 'gemini) (not elpher-gemini-TLS-cert-checks))
+ (setq-local network-security-level 'low))
+ (condition-case nil
+ (let* ((kill-buffer-query-functions nil)
+ (port (elpher-address-port address))
+ (host (elpher-address-host address))
+ (response-string-parts nil)
+ (bytes-received 0)
+ (hkbytes-received 0)
+ (proc (make-network-process :name "elpher-process"
+ :host host
+ :family (and force-ipv4 'ipv4)
+ :service (if (> port 0) port default-port)
+ :buffer nil
+ :coding 'binary
+ :noquery t
+ :nowait t
+ :tls-parameters
+ (and use-tls
+ (cons 'gnutls-x509pki
+ (gnutls-boot-parameters
+ :type 'gnutls-x509pki
+ :hostname host
+ :keylist
+ (elpher-get-current-keylist address))))))
+ (timer (run-at-time elpher-connection-timeout nil
+ (lambda ()
+ (elpher-process-cleanup)
+ (cond
+ ; Try again with IPv4
+ ((not force-ipv4)
+ (message "Connection timed out. Retrying with IPv4.")
+ (elpher-get-host-response address default-port
+ query-string
+ response-processor
+ use-tls t))
+ ((and use-tls
+ (not (eq use-tls 'gemini))
+ (or elpher-auto-disengage-TLS
+ (y-or-n-p
+ "TLS connetion failed. Disable TLS mode and retry? ")))
+ (setq elpher-use-tls nil)
+ (elpher-get-host-response address default-port
+ query-string
+ response-processor
+ nil force-ipv4))
+ (t
+ (elpher-network-error address "Connection time-out.")))))))
+ (setq elpher-network-timer timer)
+ (elpher-buffer-message (concat "Connecting to " host "..."
+ " (press 'u' to abort)"))
+ (set-process-filter proc
+ (lambda (_proc string)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
+ (setq bytes-received (+ bytes-received (length string)))
+ (let ((new-hkbytes-received (/ bytes-received 102400)))
+ (when (> new-hkbytes-received hkbytes-received)
+ (setq hkbytes-received new-hkbytes-received)
+ (elpher-buffer-message
+ (concat "("
+ (number-to-string (/ hkbytes-received 10.0))
+ " MB read)")
+ 1)))
+ (setq response-string-parts
+ (cons string response-string-parts))))
+ (set-process-sentinel proc
+ (lambda (proc event)
+ (when timer
+ (cancel-timer timer))
+ (condition-case the-error
+ (cond
+ ((string-prefix-p "open" event) ; request URL
+ (elpher-buffer-message
+ (concat "Connected to " host ". Receiving data..."
+ " (press 'u' to abort)"))
+ (let ((inhibit-eol-conversion t))
+ (process-send-string proc query-string)))
+ ((string-prefix-p "deleted" event)) ; do nothing
+ ((and (not response-string-parts)
+ (not (or elpher-ipv4-always force-ipv4)))
+ ; Try again with IPv4
+ (message "Connection failed. Retrying with IPv4.")
+ (elpher-get-host-response address default-port
+ query-string
+ response-processor
+ use-tls t))
+ (response-string-parts
+ (elpher-with-clean-buffer
+ (insert "Data received. Rendering..."))
+ (funcall response-processor
+ (apply #'concat (reverse response-string-parts)))
+ (elpher-restore-pos))
+ (t
+ (error "No response from server")))
+ (error
+ (elpher-network-error address the-error))))))
+ (error
+ (error "Error initiating connection to server")))))
-Usually errors result in an error page being displayed. This is only
-appropriate if the selector is to be directly viewed. If PROPAGATE-ERROR
-is non-nil, this message is not displayed. Instead, the error propagates
-up to the calling function."
- (setq elpher-selector-string "")
- (when (equal (elpher-address-protocol address) "gophers")
- (if (gnutls-available-p)
- (when (not elpher-use-tls)
- (setq elpher-use-tls t)
- (message "Engaging TLS gopher mode."))
- (error "Cannot retrieve TLS gopher selector: GnuTLS not available")))
- (condition-case the-error
- (let* ((kill-buffer-query-functions nil)
- (proc (open-network-stream "elpher-process"
- nil
- (elpher-address-host address)
- (elpher-address-port address)
- :type (if elpher-use-tls 'tls 'plain))))
- (set-process-coding-system proc 'binary)
- (set-process-filter proc
- (lambda (_proc string)
- (setq elpher-selector-string
- (concat elpher-selector-string string))))
- (set-process-sentinel proc after)
- (process-send-string proc
- (concat (elpher-gopher-address-selector address) "\n")))
- (error
- (if (and (consp the-error)
- (eq (car the-error) 'gnutls-error)
- (not (equal (elpher-address-protocol address) "gophers"))
- (or elpher-auto-disengage-TLS
- (yes-or-no-p "Could not establish encrypted connection. Disable TLS mode? ")))
- (progn
- (message "Disengaging TLS gopher mode.")
- (setq elpher-use-tls nil)
- (elpher-get-selector address after))
- (elpher-process-cleanup)
- (if propagate-error
- (error the-error)
- (elpher-with-clean-buffer
- (insert (propertize "\n---- ERROR -----\n\n" 'face 'error)
- "Failed to connect to " (elpher-address-to-url address) ".\n"
- (propertize "\n----------------\n\n" 'face 'error)
- "Press 'u' to return to the previous page.")))))))
-
-(defun elpher-get-gopher-node (renderer)
- "Getter function for gopher nodes.
-The RENDERER procedure is used to display the contents of the node
+
+;;; Client-side TLS Certificate Management
+;;
+
+(defun elpher-generate-certificate (common-name key-file cert-file &optional temporary)
+ "Generate a key and a self-signed client TLS certificate using openssl.
+
+The Common Name field of the certificate is set to COMMON-NAME. The
+arguments KEY-FILE and CERT-FILE should contain the absolute paths of
+the key and certificate files to write.
+
+If TEMPORARY is non-nil, the certificate will be given an exporation
+period of one day, and the key and certificate files will be deleted
+when the certificate is no longer needed for the current session.
+
+Otherwise, the certificate will be given a 100 year expiration period
+and the files will not be deleted.
+
+The function returns a list containing the current host name, the
+temporary flag, and the key and cert file names in the form required
+by `gnutls-boot-parameters`."
+ (let ((exp-key-file (expand-file-name key-file))
+ (exp-cert-file (expand-file-name cert-file)))
+ (condition-case nil
+ (progn
+ (call-process elpher-openssl-command nil nil nil
+ "req" "-x509" "-newkey" "rsa:2048"
+ "-days" (if temporary "1" "36500")
+ "-nodes"
+ "-subj" (concat "/CN=" common-name)
+ "-keyout" exp-key-file
+ "-out" exp-cert-file)
+ (list (elpher-address-host (elpher-page-address elpher-current-page))
+ temporary exp-key-file exp-cert-file))
+ (error
+ (message "Check that openssl is installed, or customize `elpher-openssl-command`.")
+ (error "Program 'openssl', required for certificate generation, not found")))))
+
+(defun elpher-generate-throwaway-certificate ()
+ "Generate and return details of a throwaway certificate.
+The key and certificate files will be deleted when they are no
+longer needed for this session."
+ (let* ((file-base (make-temp-name "elpher"))
+ (key-file (concat temporary-file-directory file-base ".key"))
+ (cert-file (concat temporary-file-directory file-base ".crt")))
+ (elpher-generate-certificate file-base key-file cert-file t)))
+
+(defun elpher-generate-persistent-certificate (file-base common-name)
+ "Generate and return details of a persistent certificate.
+The argument FILE-BASE is used as the base for the key and certificate
+files, while COMMON-NAME specifies the common name field of the
+certificate.
+
+The key and certificate files are written to in `elpher-certificate-directory'."
+ (let* ((key-file (concat elpher-certificate-directory file-base ".key"))
+ (cert-file (concat elpher-certificate-directory file-base ".crt")))
+ (elpher-generate-certificate common-name key-file cert-file)))
+
+(defun elpher-get-existing-certificate (file-base)
+ "Return a certificate object corresponding to an existing certificate.
+It is assumed that the key files FILE-BASE.key and FILE-BASE.crt exist in
+the directory `elpher-certificate-directory'."
+ (let* ((key-file (concat elpher-certificate-directory file-base ".key"))
+ (cert-file (concat elpher-certificate-directory file-base ".crt")))
+ (list (elpher-address-host (elpher-page-address elpher-current-page))
+ nil
+ (expand-file-name key-file)
+ (expand-file-name cert-file))))
+
+(defun elpher-install-and-use-existing-certificate (key-file-src cert-file-src file-base)
+ "Install a key+certificate file pair in `elpher-certificate-directory'.
+The strings KEY-FILE-SRC and CERT-FILE-SRC are the existing key and
+certificate files to install. The argument FILE-BASE is used as the
+base for the installed key and certificate files."
+ (let* ((key-file (concat elpher-certificate-directory file-base ".key"))
+ (cert-file (concat elpher-certificate-directory file-base ".crt")))
+ (if (or (file-exists-p key-file)
+ (file-exists-p cert-file))
+ (error "A certificate with base name %s is already installed" file-base))
+ (copy-file key-file-src key-file)
+ (copy-file cert-file-src cert-file)
+ (list (elpher-address-host (elpher-page-address elpher-current-page))
+ nil
+ (expand-file-name key-file)
+ (expand-file-name cert-file))))
+
+(defun elpher-list-existing-certificates ()
+ "Return a list of the persistent certificates in `elpher-certificate-directory'."
+ (unless (file-directory-p elpher-certificate-directory)
+ (make-directory elpher-certificate-directory))
+ (mapcar
+ (lambda (file)
+ (file-name-sans-extension file))
+ (directory-files elpher-certificate-directory nil "\.key$")))
+
+(defun elpher-forget-current-certificate ()
+ "Causes any current certificate to be forgotten.)
+In the case of throwaway certificates, the key and certificate files
+are also deleted."
+ (interactive)
+ (when elpher-client-certificate
+ (unless (and (called-interactively-p 'any)
+ (not (y-or-n-p (concat "Really forget client certificate? "
+ "(Throwaway certificates will be deleted.)"))))
+ (when (cadr elpher-client-certificate)
+ (delete-file (elt elpher-client-certificate 2))
+ (delete-file (elt elpher-client-certificate 3)))
+ (setq elpher-client-certificate nil)
+ (if (called-interactively-p 'any)
+ (message "Client certificate forgotten.")))))
+
+(defun elpher-get-current-keylist (address)
+ "Retrieve the `gnutls-boot-parameters'-compatable keylist.
+
+This is obtained from the client certificate described by
+`elpher-current-certificate', if one is available and the host for
+that certificate matches the host in ADDRESS.
+
+If `elpher-current-certificate' is non-nil, and its host name doesn't
+match that of ADDRESS, the certificate is forgotten."
+ (if elpher-client-certificate
+ (if (string= (car elpher-client-certificate)
+ (elpher-address-host address))
+ (list (cddr elpher-client-certificate))
+ (elpher-forget-current-certificate)
+ (message "Disabling client certificate for new host")
+ nil)
+ nil))
+
+
+;;; Gopher selector retrieval
+;;
+
+(defun elpher-get-gopher-response (address renderer)
+ "Get response string from gopher server at ADDRESS and render using RENDERER."
+ (elpher-get-host-response address 70
+ (concat (elpher-gopher-address-selector address) "\r\n")
+ renderer
+ (or (string= (elpher-address-protocol address) "gophers")
+ elpher-use-tls)))
+
+(defun elpher-get-gopher-page (renderer)
+ "Getter function for gopher pages.
+The RENDERER procedure is used to display the contents of the page
once they are retrieved from the gopher server."
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address)))
(if (and content (funcall renderer nil))
(elpher-with-clean-buffer
(insert content)
(elpher-restore-pos))
(elpher-with-clean-buffer
- (insert "LOADING... (use 'u' to cancel)"))
- (elpher-get-selector address
- (lambda (_proc event)
- (unless (string-prefix-p "deleted" event)
- (funcall renderer elpher-selector-string)
- (elpher-restore-pos)))))))
+ (insert "LOADING... (use 'u' to cancel)\n"))
+ (condition-case the-error
+ (elpher-get-gopher-response address renderer)
+ (error
+ (elpher-network-error address the-error))))))
;; Index rendering
(insert " "))
(insert (make-string elpher-margin-width ?\s))))
-(defun elpher-node-button-help (node)
- "Return a string containing the help text for a button corresponding to NODE."
- (let ((address (elpher-node-address node)))
- (format "mouse-1, RET: open '%s'" (elpher-address-to-url address))))
+(defun elpher--page-button-help (_window buffer pos)
+ "Function called by Emacs to generate mouse-over text.
+The arguments specify the BUFFER and the POS within the buffer of the item
+for which help is required. The function returns the help to be
+displayed. The _WINDOW argument is currently unused."
+ (with-current-buffer buffer
+ (let ((button (button-at pos)))
+ (when button
+ (let* ((page (button-get button 'elpher-page))
+ (address (elpher-page-address page)))
+ (format "mouse-1, RET: open '%s'" (if (elpher-address-special-p address)
+ address
+ (elpher-address-to-url address))))))))
(defun elpher-insert-index-record (display-string &optional address)
"Function to insert an index record into the current buffer.
(if type-map-entry
(let* ((margin-code (elt type-map-entry 2))
(face (elt type-map-entry 3))
- (node (elpher-make-node display-string address)))
+ (filtered-display-string (ansi-color-filter-apply display-string))
+ (page (elpher-make-page filtered-display-string address)))
(elpher-insert-margin margin-code)
- (insert-text-button display-string
+ (insert-text-button filtered-display-string
'face face
- 'elpher-node node
+ 'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-node-button-help node)))
+ 'help-echo #'elpher--page-button-help))
(pcase type
- ((or '(gopher ?i) 'nil) ;; Information
+ ('nil ;; Information
(elpher-insert-margin)
(let ((propertized-display-string
(propertize display-string 'face 'elpher-info)))
- (insert (if elpher-buttonify-urls-in-directories
- (elpher-buttonify-urls propertized-display-string)
- propertized-display-string))))
+ (insert (elpher-process-text-for-display propertized-display-string))))
(`(gopher ,selector-type) ;; Unknown
(elpher-insert-margin (concat (char-to-string selector-type) "?"))
(insert (propertize display-string
(defun elpher-click-link (button)
"Function called when the gopher link BUTTON is activated (via mouse or keypress)."
- (let ((node (button-get button 'elpher-node)))
- (elpher-visit-node node)))
+ (let ((page (button-get button 'elpher-page)))
+ (elpher-visit-page page)))
(defun elpher-render-index (data &optional _mime-type-string)
"Render DATA as an index. MIME-TYPE-STRING is unused."
(if (not data)
t
(elpher-insert-index data)
- (elpher-cache-content (elpher-node-address elpher-current-node)
+ (elpher-cache-content (elpher-page-address elpher-current-page)
(buffer-string)))))
;; Text rendering
(defconst elpher-url-regex
- "\\([a-zA-Z]+\\)://\\([a-zA-Z0-9.\-]+\\|\[[a-zA-Z0-9:]+\]\\)\\(?3::[0-9]+\\)?\\(?4:/[^<> \r\n\t(),]*\\)?"
- "Regexp used to locate and buttniofy URLs in text files loaded by elpher.")
+ "\\([a-zA-Z]+\\)://\\([a-zA-Z0-9.\-]*[a-zA-Z0-9\-]\\|\[[a-zA-Z0-9:]+\]\\)\\(:[0-9]+\\)?\\(/\\([0-9a-zA-Z\-_~?/@|:.%#=&]*[0-9a-zA-Z\-_~?/@|#]\\)?\\)?"
+ "Regexp used to locate and buttinofy URLs in text files loaded by elpher.")
(defun elpher-buttonify-urls (string)
"Turn substrings which look like urls in STRING into clickable buttons."
(insert string)
(goto-char (point-min))
(while (re-search-forward elpher-url-regex nil t)
- (let ((node (elpher-make-node (match-string 0)
+ (let ((page (elpher-make-page (substring-no-properties (match-string 0))
(elpher-address-from-url (match-string 0)))))
(make-text-button (match-beginning 0)
(match-end 0)
- 'elpher-node node
+ 'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-node-button-help node)
+ 'help-echo #'elpher--page-button-help
'face 'button)))
(buffer-string)))
+(defconst elpher-ansi-regex "\x1b\\[[^m]*m"
+ "Wildly incomplete regexp used to strip out some troublesome ANSI escape sequences.")
+
+(defun elpher-process-text-for-display (string)
+ "Perform any desired processing of STRING prior to display as text.
+Currently includes buttonifying URLs and processing ANSI escape codes."
+ (elpher-buttonify-urls (if elpher-filter-ansi-from-text
+ (ansi-color-filter-apply string)
+ (ansi-color-apply string))))
+
(defun elpher-render-text (data &optional _mime-type-string)
"Render DATA as text. MIME-TYPE-STRING is unused."
(elpher-with-clean-buffer
(if (not data)
t
- (insert (elpher-buttonify-urls (elpher-preprocess-text-response data)))
+ (insert (elpher-process-text-for-display (elpher-preprocess-text-response data)))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string)))))
;; Image retrieval
;; Search retrieval and rendering
-(defun elpher-get-gopher-query-node (renderer)
+(defun elpher-get-gopher-query-page (renderer)
"Getter for gopher addresses requiring input.
The response is rendered using the rendering function RENDERER."
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address))
(aborted t))
(if (and content (funcall renderer nil))
(elpher-with-clean-buffer
(insert "LOADING RESULTS... (use 'u' to cancel)"))
- (elpher-get-selector search-address
- (lambda (_proc event)
- (unless (string-prefix-p "deleted" event)
- (funcall renderer elpher-selector-string)
- (elpher-restore-pos)))))
+ (elpher-get-gopher-response search-address renderer))
(if aborted
- (elpher-visit-parent-node))))))
+ (elpher-visit-previous-page))))))
;; Raw server response rendering
-(defun elpher-render-raw (data &optional _mime-type-string)
- "Display raw DATA in buffer. MIME-TYPE-STRING is unused."
+(defun elpher-render-raw (data &optional mime-type-string)
+ "Display raw DATA in buffer. MIME-TYPE-STRING is also displayed if provided."
(if (not data)
nil
(elpher-with-clean-buffer
+ (when mime-type-string
+ (insert "MIME type specified by server: '" mime-type-string "'\n"))
(insert data)
(goto-char (point-min)))
(message "Displaying raw server response. Reload or redraw to return to standard view.")))
"Save DATA to file. MIME-TYPE-STRING is unused."
(if (not data)
nil
- (let* ((address (elpher-node-address elpher-current-node))
- (selector (elpher-gopher-address-selector address)))
- (elpher-visit-parent-node) ; Do first in case of non-local exits.
+ (let* ((address (elpher-page-address elpher-current-page))
+ (selector (if (elpher-address-gopher-p address)
+ (elpher-gopher-address-selector address)
+ (elpher-address-filename address))))
+ (elpher-visit-previous-page) ; Do first in case of non-local exits.
(let* ((filename-proposal (file-name-nondirectory selector))
(filename (read-file-name "Download complete. Save file as: "
nil nil nil
(libxml-parse-html-region (point-min) (point-max)))))
(shr-insert-document dom)))))
-;; Gemini node retrieval
-
-(defvar elpher-gemini-response)
-
-(defun elpher-get-gemini-response (address after)
- "Retrieve gemini ADDRESS, then execute AFTER.
-The response is stored in the variable ‘elpher-gemini-response’."
- (setq elpher-gemini-response "")
- (if (not (gnutls-available-p))
- (error "Cannot retrieve TLS selector: GnuTLS not available")
- (let* ((kill-buffer-query-functions nil)
- (proc (open-network-stream "elpher-process"
- nil
- (elpher-address-host address)
- (elpher-address-port address)
- :type 'tls)))
- (set-process-coding-system proc 'binary)
- (set-process-filter proc
- (lambda (_proc string)
- (setq elpher-gemini-response
- (concat elpher-gemini-response string))))
- (set-process-sentinel proc after)
- (process-send-string proc
- (concat (elpher-address-to-url address) "\r\n")))))
-
-
-(defun elpher-process-gemini-response (renderer)
- "Process the gemini response and pass the result to RENDERER.
-The response is assumed to be in the variable `elpher-gemini-response'."
- (condition-case the-error
- (let* ((response-header (car (split-string elpher-gemini-response "\r\n")))
- (response-body (substring elpher-gemini-response
- (+ (string-match "\r\n" elpher-gemini-response) 2)))
- (response-code (car (split-string response-header)))
- (response-meta (string-trim
- (substring response-header
- (string-match "[ \t]+" response-header)))))
- (pcase (elt response-code 0)
- (?1 ; Input required
- (elpher-with-clean-buffer
- (insert "Gemini server is requesting input."))
- (let* ((query-string (read-string (concat response-meta ": ")))
- (url (elpher-address-to-url (elpher-node-address elpher-current-node)))
- (query-address (elpher-address-from-url (concat url "?" query-string))))
- (elpher-get-gemini-response query-address
- (lambda (_proc event)
- (unless (string-prefix-p "deleted" event)
- (funcall #'elpher-process-gemini-response
- renderer)
- (elpher-restore-pos))))))
- (?2 ; Normal response
- ;; (message response-header)
- (funcall renderer response-body response-meta))
- (?3 ; Redirect
- (message "Following redirect to %s" response-meta)
- (let ((redirect-address (elpher-address-from-gemini-url response-meta)))
- (elpher-get-gemini-response redirect-address
- (lambda (_proc event)
- (unless (string-prefix-p "deleted" event)
- (funcall #'elpher-process-gemini-response
- renderer)
- (elpher-restore-pos))))))
- (?4 ; Temporary failure
- (error "Gemini server reports TEMPORARY FAILURE for this request"))
- (?5 ; Permanent failure
- (error "Gemini server reports PERMANENT FAILURE for this request"))
- (?6 ; Client certificate required
- (error "Gemini server requires client certificate (unsupported at this time)"))
- (_other
- (error "Gemini server responded with unknown response code %S"
- response-code))))
- (error
- (elpher-network-error (elpher-node-address elpher-current-node) the-error))))
-
-(defun elpher-get-gemini-node (renderer)
- "Getter which retrieves and renders a Gemini node and renders it using RENDERER."
- (let* ((address (elpher-node-address elpher-current-node))
+;; Gemini page retrieval
+
+(defvar elpher-gemini-redirect-chain)
+
+(defun elpher-get-gemini-response (address renderer)
+ "Get response string from gemini server at ADDRESS and render using RENDERER."
+ (elpher-get-host-response address 1965
+ (concat (elpher-address-to-url address) "\r\n")
+ (lambda (response-string)
+ (elpher-process-gemini-response response-string renderer))
+ 'gemini))
+
+(defun elpher-parse-gemini-response (response)
+ "Parse the RESPONSE string and return a list of components.
+The list is of the form (code meta body). A response of nil implies
+that the response was malformed."
+ (let ((header-end-idx (string-match "\r\n" response)))
+ (if header-end-idx
+ (let ((header (string-trim (substring response 0 header-end-idx)))
+ (body (substring response (+ header-end-idx 2))))
+ (if (>= (length header) 2)
+ (let ((code (substring header 0 2))
+ (meta (string-trim (substring header 2))))
+ (list code meta body))
+ (error "Malformed response: No response status found in header %s" header)))
+ (error "Malformed response: No CRLF-delimited header found in response %s" response))))
+
+(defun elpher-process-gemini-response (response-string renderer)
+ "Process the gemini response RESPONSE-STRING and pass the result to RENDERER."
+ (let ((response-components (elpher-parse-gemini-response response-string)))
+ (let ((response-code (elt response-components 0))
+ (response-meta (elt response-components 1))
+ (response-body (elt response-components 2)))
+ (pcase (elt response-code 0)
+ (?1 ; Input required
+ (elpher-with-clean-buffer
+ (insert "Gemini server is requesting input."))
+ (let* ((query-string
+ (if (eq (elt response-code 1) ?1)
+ (read-passwd (concat response-meta ": "))
+ (read-string (concat response-meta ": "))))
+ (query-address (seq-copy (elpher-page-address elpher-current-page)))
+ (old-fname (url-filename query-address)))
+ (setf (url-filename query-address)
+ (concat old-fname "?" (url-build-query-string `((,query-string)))))
+ (elpher-get-gemini-response query-address renderer)))
+ (?2 ; Normal response
+ (funcall renderer response-body response-meta))
+ (?3 ; Redirect
+ (message "Following redirect to %s" response-meta)
+ (if (>= (length elpher-gemini-redirect-chain) 5)
+ (error "More than 5 consecutive redirects followed"))
+ (let ((redirect-address (elpher-address-from-gemini-url response-meta)))
+ (if (member redirect-address elpher-gemini-redirect-chain)
+ (error "Redirect loop detected"))
+ (if (not (string= (elpher-address-protocol redirect-address)
+ "gemini"))
+ (error "Server tried to automatically redirect to non-gemini URL: %s"
+ response-meta))
+ (elpher-page-set-address elpher-current-page redirect-address)
+ (add-to-list 'elpher-gemini-redirect-chain redirect-address)
+ (elpher-get-gemini-response redirect-address renderer)))
+ (?4 ; Temporary failure
+ (error "Gemini server reports TEMPORARY FAILURE for this request: %s %s"
+ response-code response-meta))
+ (?5 ; Permanent failure
+ (error "Gemini server reports PERMANENT FAILURE for this request: %s %s"
+ response-code response-meta))
+ (?6 ; Client certificate required
+ (elpher-with-clean-buffer
+ (if elpher-client-certificate
+ (insert "Gemini server does not recognise the provided TLS certificate:\n\n")
+ (insert "Gemini server is requesting a valid TLS certificate:\n\n"))
+ (auto-fill-mode 1)
+ (elpher-gemini-insert-text response-meta))
+ (let ((chosen-certificate (elpher-choose-client-certificate)))
+ (unless chosen-certificate
+ (error "Gemini server requires a client certificate and none was provided"))
+ (setq elpher-client-certificate chosen-certificate))
+ (elpher-with-clean-buffer)
+ (elpher-get-gemini-response (elpher-page-address elpher-current-page) renderer))
+ (_other
+ (error "Gemini server response unknown: %s %s"
+ response-code response-meta))))))
+
+(defun elpher-choose-client-certificate ()
+ "Prompt for a client certificate to use to establish a TLS connection."
+ (let* ((read-answer-short t))
+ (pcase (read-answer "What do you want to do? "
+ '(("throwaway" ?t
+ "generate and use throw-away certificate")
+ ("persistent" ?p
+ "generate new or use existing persistent certificate")
+ ("abort" ?a
+ "stop immediately")))
+ ("throwaway"
+ (setq elpher-client-certificate (elpher-generate-throwaway-certificate)))
+ ("persistent"
+ (let* ((existing-certificates (elpher-list-existing-certificates))
+ (file-base (completing-read
+ "Nickname for new or existing certificate (autocompletes, empty response aborts): "
+ existing-certificates)))
+ (if (string-empty-p (string-trim file-base))
+ nil
+ (if (member file-base existing-certificates)
+ (setq elpher-client-certificate
+ (elpher-get-existing-certificate file-base))
+ (pcase (read-answer "Generate new certificate or install externally-generated one? "
+ '(("new" ?n
+ "generate new certificate")
+ ("install" ?i
+ "install existing certificate")
+ ("abort" ?a
+ "stop immediately")))
+ ("new"
+ (let ((common-name (read-string "Common Name field for new certificate: "
+ file-base)))
+ (message "New key and self-signed certificate written to %s"
+ elpher-certificate-directory)
+ (elpher-generate-persistent-certificate file-base common-name)))
+ ("install"
+ (let* ((cert-file (read-file-name "Certificate file: " nil nil t))
+ (key-file (read-file-name "Key file: " nil nil t)))
+ (message "Key and certificate installed in %s for future use"
+ elpher-certificate-directory)
+ (elpher-install-and-use-existing-certificate key-file
+ cert-file
+ file-base)))
+ ("abort" nil))))))
+ ("abort" nil))))
+
+(defun elpher-get-gemini-page (renderer)
+ "Getter which retrieves and renders a Gemini page and renders it using RENDERER."
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address)))
(condition-case the-error
(if (and content (funcall renderer nil))
(insert content)
(elpher-restore-pos))
(elpher-with-clean-buffer
- (insert "LOADING GEMINI... (use 'u' to cancel)"))
- (elpher-get-gemini-response address
- (lambda (_proc event)
- (unless (string-prefix-p "deleted" event)
- (funcall #'elpher-process-gemini-response
- renderer)
- (elpher-restore-pos)))))
+ (insert "LOADING GEMINI... (use 'u' to cancel)\n"))
+ (setq elpher-gemini-redirect-chain nil)
+ (elpher-get-gemini-response address renderer))
(error
(elpher-network-error address the-error)))))
-
(defun elpher-render-gemini (body &optional mime-type-string)
"Render gemini response BODY with rendering MIME-TYPE-STRING."
(if (not body)
(list (downcase (string-trim (car key-val)))
(downcase (string-trim (cadr key-val))))))
(cdr mime-type-split))))
- (if (and (equal "text/gemini" mime-type)
- (not (assoc "charset" parameters)))
- (setq parameters (cons (list "charset" "utf-8") parameters)))
(when (string-prefix-p "text/" mime-type)
- (if (assoc "charset" parameters)
- (setq body (decode-coding-string body
- (intern (cadr (assoc "charset" parameters))))))
+ (setq body (decode-coding-string
+ body
+ (if (assoc "charset" parameters)
+ (intern (cadr (assoc "charset" parameters)))
+ 'utf-8)))
(setq body (replace-regexp-in-string "\r" "" body)))
(pcase mime-type
((or "text/gemini" "")
(elpher-render-gemini-map body parameters))
+ ("text/html"
+ (elpher-render-html body))
((pred (string-prefix-p "text/"))
(elpher-render-gemini-plain-text body parameters))
((pred (string-prefix-p "image/"))
(elpher-render-image body))
(_other
- (error "Unsupported MIME type %S" mime-type))))))
-
-(defun elpher-gemini-get-link-url (line)
- "Extract the url portion of LINE, a gemini map file link line."
- (string-trim (elt (split-string (substring line 2)) 0)))
-
-(defun elpher-gemini-get-link-display-string (line)
- "Extract the display string portion of LINE, a gemini map file link line."
- (let* ((rest (string-trim (elt (split-string line "=>") 1)))
+ (elpher-render-download body))))))
+
+(defun elpher-gemini-get-link-url (link-line)
+ "Extract the url portion of LINK-LINE, a gemini map file link line.
+Returns nil in the event that the contents of the line following the
+=> prefix are empty."
+ (let ((l (split-string (substring link-line 2))))
+ (if l
+ (string-trim (elt l 0))
+ nil)))
+
+(defun elpher-gemini-get-link-display-string (link-line)
+ "Extract the display string portion of LINK-LINE, a gemini map file link line.
+Returns the url portion in the event that the display-string portion is empty."
+ (let* ((rest (string-trim (elt (split-string link-line "=>") 1)))
(idx (string-match "[ \t]" rest)))
- (if idx
- (string-trim (substring rest (+ idx 1)))
- "")))
+ (string-trim (if idx
+ (substring rest (+ idx 1))
+ rest))))
+
+(defun elpher-collapse-dot-sequences (filename)
+ "Collapse dot sequences in FILENAME.
+For instance, the filename /a/b/../c/./d will reduce to /a/c/d"
+ (let* ((path (split-string filename "/"))
+ (path-reversed-normalized
+ (seq-reduce (lambda (a b)
+ (cond ((and a (equal b "..") (cdr a)))
+ ((and (not a) (equal b "..")) a) ;leading .. are dropped
+ ((equal b ".") a)
+ (t (cons b a))))
+ path nil)))
+ (string-join (reverse path-reversed-normalized) "/")))
(defun elpher-address-from-gemini-url (url)
- "Extract address from URL with defaults as per gemini map files."
- (let ((address (url-generic-parse-url url)))
+ "Extract address from URL with defaults as per gemini map files.
+While there's obviously some redundancy here between this function and
+`elpher-address-from-url', gemini map file URLs require enough special
+treatment that a separate function is warranted."
+ (let ((address (url-generic-parse-url url))
+ (current-address (elpher-page-address elpher-current-page)))
(unless (and (url-type address) (not (url-fullness address))) ;avoid mangling mailto: urls
(setf (url-fullness address) t)
- (unless (url-host address) ;if there is an explicit host, filenames are absolute
- (setf (url-host address) (url-host (elpher-node-address elpher-current-node)))
+ (if (url-host address) ;if there is an explicit host, filenames are absolute
+ (if (string-empty-p (url-filename address))
+ (setf (url-filename address) "/")) ;ensure empty filename is marked as absolute
+ (setf (url-host address) (url-host current-address))
+ (setf (url-port address) (url-port current-address))
(unless (string-prefix-p "/" (url-filename address)) ;deal with relative links
(setf (url-filename address)
- (concat (file-name-directory
- (url-filename (elpher-node-address elpher-current-node)))
+ (concat (file-name-directory (url-filename current-address))
(url-filename address)))))
(unless (url-type address)
- (setf (url-type address) "gemini")))
- address))
+ (setf (url-type address) "gemini"))
+ (when (equal (url-type address) "gemini")
+ (setf (url-filename address)
+ (elpher-collapse-dot-sequences (url-filename address)))))
+ (elpher-remove-redundant-ports address)))
+
+(defun elpher-gemini-insert-link (link-line)
+ "Insert link described by LINK-LINE into a text/gemini document."
+ (let* ((url (elpher-gemini-get-link-url link-line))
+ (display-string (elpher-gemini-get-link-display-string link-line))
+ (address (elpher-address-from-gemini-url url))
+ (type (if address (elpher-address-type address) nil))
+ (type-map-entry (cdr (assoc type elpher-type-map))))
+ (when display-string
+ (insert elpher-gemini-link-string)
+ (if type-map-entry
+ (let* ((face (elt type-map-entry 3))
+ (filtered-display-string (ansi-color-filter-apply display-string))
+ (page (elpher-make-page filtered-display-string address)))
+ (insert-text-button filtered-display-string
+ 'face face
+ 'elpher-page page
+ 'action #'elpher-click-link
+ 'follow-link t
+ 'help-echo #'elpher--page-button-help))
+ (insert (propertize display-string 'face 'elpher-unknown)))
+ (insert "\n"))))
+
+(defun elpher-gemini-insert-header (header-line)
+ "Insert header described by HEADER-LINE into a text/gemini document.
+The gemini map file line describing the header is given
+by HEADER-LINE."
+ (when (string-match "^\\(#+\\)[ \t]*" header-line)
+ (let* ((level (length (match-string 1 header-line)))
+ (header (substring header-line (match-end 0)))
+ (face (pcase level
+ (1 'elpher-gemini-heading1)
+ (2 'elpher-gemini-heading2)
+ (3 'elpher-gemini-heading3)
+ (_ 'default)))
+ (fill-column (/ (* fill-column
+ (font-get (font-spec :name (face-font 'default)) :size))
+ (font-get (font-spec :name (face-font face)) :size))))
+ (unless (display-graphic-p)
+ (insert (make-string level ?#) " "))
+ (insert (propertize header 'face face))
+ (newline))))
+
+(defun elpher-gemini-insert-text (text-line)
+ "Insert a plain non-preformatted TEXT-LINE into a text/gemini document.
+This function uses Emacs' auto-fill to wrap text sensibly to a maximum
+width defined by elpher-gemini-max-fill-width."
+ (string-match "\\(^[ \t]*\\)\\(\*[ \t]+\\|>[ \t]*\\)?" text-line)
+ (let* ((processed-text-line (if (match-string 2 text-line)
+ (concat
+ (replace-regexp-in-string "\*"
+ elpher-gemini-bullet-string
+ (match-string 0 text-line))
+ (substring text-line (match-end 0)))
+ text-line))
+ (adaptive-fill-mode nil)
+ (fill-prefix (if (match-string 2 text-line)
+ (replace-regexp-in-string "[>\*]" " " (match-string 0 text-line))
+ nil)))
+ (insert (elpher-process-text-for-display processed-text-line))
+ (newline)))
(defun elpher-render-gemini-map (data _parameters)
"Render DATA as a gemini map file, PARAMETERS is currently unused."
(elpher-with-clean-buffer
- (dolist (line (split-string data "\n"))
- (if (string-prefix-p "=>" line)
- (let* ((url (elpher-gemini-get-link-url line))
- (display-string (elpher-gemini-get-link-display-string line))
- (address (elpher-address-from-gemini-url url)))
- (if (> (length display-string) 0)
- (elpher-insert-index-record display-string address)
- (elpher-insert-index-record url address)))
- (elpher-insert-index-record line)))
+ (let ((preformatted nil))
+ (auto-fill-mode 1)
+ (setq-local fill-column (min (window-width) elpher-gemini-max-fill-width))
+ (dolist (line (split-string data "\n"))
+ (cond
+ ((string-prefix-p "```" line) (setq preformatted (not preformatted)))
+ (preformatted (insert (elpher-process-text-for-display
+ (propertize line 'face 'elpher-gemini-preformatted))
+ "\n"))
+ ((string-prefix-p "=>" line) (elpher-gemini-insert-link line))
+ ((string-prefix-p "#" line) (elpher-gemini-insert-header line))
+ (t (elpher-gemini-insert-text line)))))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string))))
(defun elpher-render-gemini-plain-text (data _parameters)
"Render DATA as plain text file. PARAMETERS is currently unused."
(elpher-with-clean-buffer
- (insert (elpher-buttonify-urls data))
+ (insert (elpher-process-text-for-display data))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string))))
-;; Other URL node opening
-(defun elpher-get-other-url-node (renderer)
- "Getter which attempts to open the URL specified by the current node (RENDERER must be nil)."
+;; Finger page connection
+
+(defun elpher-get-finger-page (renderer)
+ "Opens a finger connection to the current page address.
+The result is rendered using RENDERER."
+ (let* ((address (elpher-page-address elpher-current-page))
+ (content (elpher-get-cached-content address)))
+ (if (and content (funcall renderer nil))
+ (elpher-with-clean-buffer
+ (insert content)
+ (elpher-restore-pos))
+ (elpher-with-clean-buffer
+ (insert "LOADING... (use 'u' to cancel)\n"))
+ (condition-case the-error
+ (let* ((kill-buffer-query-functions nil)
+ (user (let ((filename (elpher-address-filename address)))
+ (if (> (length filename) 1)
+ (substring filename 1)
+ (elpher-address-user address)))))
+ (elpher-get-host-response address 79
+ (concat user "\r\n")
+ renderer))
+ (error
+ (elpher-network-error address the-error))))))
+
+
+;; Telnet page connection
+
+(defun elpher-get-telnet-page (renderer)
+ "Opens a telnet connection to the current page address (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
+ (error "Command not supported for telnet URLs"))
+ (let* ((address (elpher-page-address elpher-current-page))
+ (host (elpher-address-host address))
+ (port (elpher-address-port address)))
+ (elpher-visit-previous-page)
+ (if (> port 0)
+ (telnet host port)
+ (telnet host))))
+
+
+;; Other URL page opening
+
+(defun elpher-get-other-url-page (renderer)
+ "Getter which attempts to open the URL specified by the current page (RENDERER must be nil)."
+ (when renderer
+ (elpher-visit-previous-page)
(error "Command not supported for general URLs"))
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(url (elpher-address-to-url address)))
(progn
- (elpher-visit-parent-node) ; Do first in case of non-local exits.
+ (elpher-visit-previous-page) ; Do first in case of non-local exits.
(message "Opening URL...")
(if elpher-open-urls-with-eww
(browse-web url)
(browse-url url)))))
-;; Telnet node connection
-(defun elpher-get-telnet-node (renderer)
- "Opens a telnet connection to the current node address (RENDERER must be nil)."
- (when renderer
- (elpher-visit-parent-node)
- (error "Command not supported for telnet URLs"))
- (let* ((address (elpher-node-address elpher-current-node))
- (host (elpher-address-host address))
- (port (elpher-address-port address)))
- (elpher-visit-parent-node)
- (telnet host port)))
-
-;; Start page node retrieval
+;; Start page page retrieval
-(defun elpher-get-start-node (renderer)
+(defun elpher-get-start-page (renderer)
"Getter which displays the start page (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for start page"))
(elpher-with-clean-buffer
(insert " --------------------------------------------\n"
- " Elpher Gopher Client \n"
+ " Elpher Gopher and Gemini Client \n"
" version " elpher-version "\n"
" --------------------------------------------\n"
"\n"
" - TAB/Shift-TAB: next/prev item on current page\n"
" - RET/mouse-1: open item under cursor\n"
" - m: select an item on current page by name (autocompletes)\n"
- " - u: return to previous page\n"
+ " - u/mouse-3/U: return to previous page or to the start page\n"
" - o/O: visit different selector or the root menu of the current server\n"
- " - g: go to a particular gopher address\n"
+ " - g: go to a particular address (gopher, gemini, finger)\n"
" - d/D: download item under cursor or current page\n"
" - i/I: info on item under cursor or current page\n"
" - c/C: copy URL representation of item under cursor or current page\n"
" - R: reload current page (regenerates cache)\n"
" - S: set character coding system for gopher (default is to autodetect)\n"
" - T: toggle TLS gopher mode\n"
+ " - F: forget/discard current TLS client certificate\n"
" - .: display the raw server response for the current page\n"
"\n"
- "Start your exploration of gopher space:\n")
+ "Start your exploration of gopher space and gemini:\n")
(elpher-insert-index-record "Floodgap Systems Gopher Server"
(elpher-make-gopher-address ?1 "" "gopher.floodgap.com" 70))
+ (elpher-insert-index-record "Project Gemini home page"
+ (elpher-address-from-url "gemini://gemini.circumlunar.space/"))
(insert "\n"
- "Alternatively, select the following item and enter some search terms:\n")
- (elpher-insert-index-record "Veronica-2 Gopher Search Engine"
+ "Alternatively, select a search engine and enter some search terms:\n")
+ (elpher-insert-index-record "Gopher Search Engine (Veronica-2)"
(elpher-make-gopher-address ?7 "/v2/vs" "gopher.floodgap.com" 70))
+ (elpher-insert-index-record "Gemini Search Engine (GUS)"
+ (elpher-address-from-url "gemini://gus.guru/search"))
+ (insert "\n"
+ "This page contains your bookmarked sites (also visit with B):\n")
+ (elpher-insert-index-record "Your Bookmarks" 'bookmarks)
+ (insert "\n"
+ "For Elpher release news or to leave feedback, visit:\n")
+ (elpher-insert-index-record "The Elpher Project Page"
+ (elpher-make-gopher-address ?1
+ "/projects/elpher/"
+ "thelambdalab.xyz"
+ 70))
(insert "\n"
"** Refer to the ")
(let ((help-string "RET,mouse-1: Open Elpher info manual (if available)"))
(insert " for the full documentation. **\n")
(insert (propertize
(concat " (This should be available if you have installed Elpher using\n"
- " MELPA. Otherwise you will have to install the manual yourself.)")
+ " MELPA. Otherwise you will have to install the manual yourself.)\n")
'face 'shadow))
(elpher-restore-pos)))
-;; Bookmarks page node retrieval
+;; Bookmarks page page retrieval
-(defun elpher-get-bookmarks-node (renderer)
+(defun elpher-get-bookmarks-page (renderer)
"Getter to load and display the current bookmark list (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for bookmarks page"))
(elpher-with-clean-buffer
(insert "---- Bookmark list ----\n\n")
(address (elpher-address-from-url (elpher-bookmark-url bookmark))))
(elpher-insert-index-record display-string address)))
(insert "No bookmarks found.\n")))
- (insert "\n-----------------------\n\n"
+ (insert "\n-----------------------\n"
+ "\n"
"- u: return to previous page\n"
"- x: delete selected bookmark\n"
- "- a: rename selected bookmark\n\n"
- "Bookmarks are stored in the file "
- (locate-user-emacs-file "elpher-bookmarks"))
+ "- a: rename selected bookmark\n"
+ "\n"
+ "Bookmarks are stored in the file ")
+ (let ((filename elpher-bookmarks-file)
+ (help-string "RET,mouse-1: Open bookmarks file in new buffer for editing."))
+ (insert-text-button filename
+ 'face 'link
+ 'action (lambda (_)
+ (interactive)
+ (find-file filename))
+ 'follow-link t
+ 'help-echo help-string))
+ (insert "\n")
(elpher-restore-pos)))
(defun elpher-save-bookmarks (bookmarks)
"Record the bookmark list BOOKMARKS to the user's bookmark file.
Beware that this completely replaces the existing contents of the file."
- (with-temp-file (locate-user-emacs-file "elpher-bookmarks")
+ (with-temp-file elpher-bookmarks-file
(erase-buffer)
(insert "; Elpher bookmarks file\n\n"
"; Bookmarks are stored as a list of (label URL) items.\n"
(let ((bookmarks
(with-temp-buffer
(ignore-errors
- (insert-file-contents (locate-user-emacs-file "elpher-bookmarks"))
+ (insert-file-contents elpher-bookmarks-file)
(goto-char (point-min))
(read (current-buffer))))))
(if (and bookmarks (listp (cadar bookmarks)))
(interactive)
(push-button))
-(defun elpher-go ()
- "Go to a particular gopher site read from the minibuffer."
- (interactive)
- (let ((node
- (let ((host-or-url (read-string "Gopher or Gemini URL: ")))
- (elpher-make-node host-or-url
- (elpher-address-from-url host-or-url)))))
- (switch-to-buffer "*elpher*")
- (elpher-visit-node node)))
+(defun elpher-go (host-or-url)
+ "Go to a particular gopher site HOST-OR-URL.
+When run interactively HOST-OR-URL is read from the minibuffer."
+ (interactive "sGopher or Gemini URL: ")
+ (let* ((cleaned-host-or-url (string-trim host-or-url))
+ (address (elpher-address-from-url cleaned-host-or-url))
+ (page (elpher-make-page cleaned-host-or-url address)))
+ (switch-to-buffer elpher-buffer-name)
+ (elpher-visit-page page)
+ nil))
(defun elpher-go-current ()
"Go to a particular site read from the minibuffer, initialized with the current URL."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page)))
(if (elpher-address-special-p address)
(error "Command invalid for this page")
(let ((url (read-string "Gopher or Gemini URL: " (elpher-address-to-url address))))
- (elpher-visit-node (elpher-make-node url (elpher-address-from-url url)))))))
+ (elpher-visit-page (elpher-make-page url (elpher-address-from-url url)))))))
(defun elpher-redraw ()
"Redraw current page."
(interactive)
- (if elpher-current-node
- (elpher-visit-node elpher-current-node)
- (message "No current site.")))
+ (elpher-visit-page elpher-current-page))
(defun elpher-reload ()
"Reload current page."
(interactive)
- (if elpher-current-node
- (elpher-reload-current-node)
- (message "No current site.")))
+ (elpher-reload-current-page))
(defun elpher-toggle-tls ()
- "Toggle TLS encryption mode."
+ "Toggle TLS encryption mode for gopher."
(interactive)
(setq elpher-use-tls (not elpher-use-tls))
(if elpher-use-tls
(defun elpher-view-raw ()
"View raw server response for current page."
(interactive)
- (if elpher-current-node
- (if (elpher-address-special-p (elpher-node-address elpher-current-node))
- (error "This page was not generated by a server")
- (elpher-visit-node elpher-current-node
- #'elpher-render-raw))
- (message "No current site.")))
+ (if (elpher-address-special-p (elpher-page-address elpher-current-page))
+ (error "This page was not generated by a server")
+ (elpher-visit-page elpher-current-page
+ #'elpher-render-raw)))
(defun elpher-back ()
"Go to previous site."
(interactive)
- (if (elpher-node-parent elpher-current-node)
- (elpher-visit-parent-node)
- (error "No previous site")))
+ (elpher-visit-previous-page))
+
+(defun elpher-back-to-start ()
+ "Go all the way back to the start page."
+ (interactive)
+ (setq-local elpher-current-page nil)
+ (setq-local elpher-history nil)
+ (let ((start-page (elpher-make-page "Elpher Start Page"
+ (elpher-make-special-address 'start))))
+ (elpher-visit-page start-page)))
(defun elpher-download ()
"Download the link at point."
(interactive)
(let ((button (button-at (point))))
(if button
- (let ((node (button-get button 'elpher-node)))
- (if (elpher-address-special-p (elpher-node-address node))
+ (let ((page (button-get button 'elpher-page)))
+ (if (elpher-address-special-p (elpher-page-address page))
(error "Cannot download %s"
- (elpher-node-display-string node))
- (elpher-visit-node (button-get button 'elpher-node)
+ (elpher-page-display-string page))
+ (elpher-visit-page (button-get button 'elpher-page)
#'elpher-render-download)))
(error "No link selected"))))
(defun elpher-download-current ()
"Download the current page."
(interactive)
- (if (elpher-address-special-p (elpher-node-address elpher-current-node))
+ (if (elpher-address-special-p (elpher-page-address elpher-current-page))
(error "Cannot download %s"
- (elpher-node-display-string elpher-current-node))
- (elpher-visit-node (elpher-make-node
- (elpher-node-display-string elpher-current-node)
- (elpher-node-address elpher-current-node)
- elpher-current-node)
+ (elpher-page-display-string elpher-current-page))
+ (elpher-visit-page (elpher-make-page
+ (elpher-page-display-string elpher-current-page)
+ (elpher-page-address elpher-current-page))
#'elpher-render-download
t)))
(defun elpher-build-link-map ()
- "Build alist mapping link names to destination nodes in current buffer."
+ "Build alist mapping link names to destination pages in current buffer."
(let ((link-map nil)
(b (next-button (point-min) t)))
(while b
(defun elpher-root-dir ()
"Visit root of current server."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page)))
(if (not (elpher-address-special-p address))
(if (or (member (url-filename address) '("/" ""))
(and (elpher-address-gopher-p address)
(let ((address-copy (elpher-address-from-url
(elpher-address-to-url address))))
(setf (url-filename address-copy) "")
- (elpher-visit-node
- (elpher-make-node (elpher-address-to-url address-copy)
- address-copy))))
- (error "Command invalid for %s" (elpher-node-display-string elpher-current-node)))))
+ (elpher-go (elpher-address-to-url address-copy))))
+ (error "Command invalid for %s" (elpher-page-display-string elpher-current-page)))))
(defun elpher-bookmarks-current-p ()
- "Return non-nil if current node is a bookmarks page."
- (equal (elpher-address-type (elpher-node-address elpher-current-node))
+ "Return non-nil if current page is a bookmarks page."
+ (equal (elpher-address-type (elpher-page-address elpher-current-page))
'(special bookmarks)))
(defun elpher-reload-bookmarks ()
- "Reload bookmarks if current node is a bookmarks page."
+ "Reload bookmarks if current page is a bookmarks page."
(if (elpher-bookmarks-current-p)
- (elpher-reload-current-node)))
+ (elpher-reload-current-page)))
(defun elpher-bookmark-current ()
- "Bookmark the current node."
+ "Bookmark the current page."
(interactive)
- (let ((address (elpher-node-address elpher-current-node))
- (display-string (elpher-node-display-string elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page))
+ (display-string (elpher-page-display-string elpher-current-page)))
(if (not (elpher-address-special-p address))
(let ((bookmark-display-string (read-string "Bookmark display string: "
display-string)))
(interactive)
(let ((button (button-at (point))))
(if button
- (let* ((node (button-get button 'elpher-node))
- (address (elpher-node-address node))
- (display-string (elpher-node-display-string node)))
+ (let* ((page (button-get button 'elpher-page))
+ (address (elpher-page-address page))
+ (display-string (elpher-page-display-string page)))
(if (not (elpher-address-special-p address))
(let ((bookmark-display-string (read-string "Bookmark display string: "
display-string)))
(error "No link selected"))))
(defun elpher-unbookmark-current ()
- "Remove bookmark for the current node."
+ "Remove bookmark for the current page."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
- (unless (elpher-address-special-p address)
+ (let ((address (elpher-page-address elpher-current-page)))
+ (when (and (not (elpher-address-special-p address))
+ (y-or-n-p "Really remove bookmark for the current page? "))
(elpher-remove-address-bookmark address)
(message "Bookmark removed."))))
(interactive)
(let ((button (button-at (point))))
(if button
- (let ((node (button-get button 'elpher-node)))
- (elpher-remove-address-bookmark (elpher-node-address node))
- (elpher-reload-bookmarks)
- (message "Bookmark removed."))
+ (when (y-or-n-p "Really remove bookmark for this link? ")
+ (let ((page (button-get button 'elpher-page)))
+ (elpher-remove-address-bookmark (elpher-page-address page))
+ (elpher-reload-bookmarks)
+ (message "Bookmark removed.")))
(error "No link selected"))))
(defun elpher-bookmarks ()
"Visit bookmarks page."
(interactive)
- (switch-to-buffer "*elpher*")
- (elpher-visit-node
- (elpher-make-node "Bookmarks Page" (elpher-make-special-address 'bookmarks))))
-
-(defun elpher-info-node (node)
- "Display information on NODE."
- (let ((display-string (elpher-node-display-string node))
- (address (elpher-node-address node)))
+ (switch-to-buffer elpher-buffer-name)
+ (elpher-visit-page
+ (elpher-make-page "Bookmarks Page" (elpher-make-special-address 'bookmarks))))
+
+(defun elpher-info-page (page)
+ "Display information on PAGE."
+ (let ((display-string (elpher-page-display-string page))
+ (address (elpher-page-address page)))
(if (elpher-address-special-p address)
(message "Special page: %s" display-string)
- (message (elpher-address-to-url address)))))
+ (message "%s" (elpher-address-to-url address)))))
(defun elpher-info-link ()
- "Display information on node corresponding to link at point."
+ "Display information on page corresponding to link at point."
(interactive)
(let ((button (button-at (point))))
(if button
- (elpher-info-node (button-get button 'elpher-node))
+ (elpher-info-page (button-get button 'elpher-page))
(error "No item selected"))))
(defun elpher-info-current ()
- "Display information on current node."
+ "Display information on current page."
(interactive)
- (elpher-info-node elpher-current-node))
+ (elpher-info-page elpher-current-page))
-(defun elpher-copy-node-url (node)
- "Copy URL representation of address of NODE to `kill-ring'."
- (let ((address (elpher-node-address node)))
+(defun elpher-copy-page-url (page)
+ "Copy URL representation of address of PAGE to `kill-ring'."
+ (let ((address (elpher-page-address page)))
(if (elpher-address-special-p address)
- (error (format "Cannot represent %s as URL" (elpher-node-display-string node)))
+ (error (format "Cannot represent %s as URL" (elpher-page-display-string page)))
(let ((url (elpher-address-to-url address)))
(message "Copied \"%s\" to kill-ring/clipboard." url)
(kill-new url)))))
(interactive)
(let ((button (button-at (point))))
(if button
- (elpher-copy-node-url (button-get button 'elpher-node))
+ (elpher-copy-page-url (button-get button 'elpher-page))
(error "No item selected"))))
(defun elpher-copy-current-url ()
- "Copy URL of current node to `kill-ring'."
+ "Copy URL of current page to `kill-ring'."
(interactive)
- (elpher-copy-node-url elpher-current-node))
+ (elpher-copy-page-url elpher-current-page))
(defun elpher-set-gopher-coding-system ()
"Specify an explicit character coding system for gopher selectors."
(let ((map (make-sparse-keymap)))
(define-key map (kbd "TAB") 'elpher-next-link)
(define-key map (kbd "<backtab>") 'elpher-prev-link)
+ (define-key map (kbd "C-M-i") 'elpher-prev-link)
(define-key map (kbd "u") 'elpher-back)
+ (define-key map (kbd "U") 'elpher-back-to-start)
(define-key map [mouse-3] 'elpher-back)
(define-key map (kbd "O") 'elpher-root-dir)
(define-key map (kbd "g") 'elpher-go)
(define-key map (kbd "X") 'elpher-unbookmark-current)
(define-key map (kbd "B") 'elpher-bookmarks)
(define-key map (kbd "S") 'elpher-set-gopher-coding-system)
+ (define-key map (kbd "F") 'elpher-forget-current-certificate)
(when (fboundp 'evil-define-key*)
(evil-define-key* 'motion map
(kbd "TAB") 'elpher-next-link
(kbd "C-") 'elpher-follow-current-link
(kbd "C-t") 'elpher-back
(kbd "u") 'elpher-back
+ (kbd "U") 'elpher-back-to-start
[mouse-3] 'elpher-back
(kbd "g") 'elpher-go
(kbd "o") 'elpher-go-current
(kbd "x") 'elpher-unbookmark-link
(kbd "X") 'elpher-unbookmark-current
(kbd "B") 'elpher-bookmarks
- (kbd "S") 'elpher-set-gopher-coding-system))
+ (kbd "S") 'elpher-set-gopher-coding-system
+ (kbd "F") 'elpher-forget-current-certificate))
map)
"Keymap for gopher client.")
This mode is automatically enabled by the interactive
functions which initialize the gopher client, namely
-`elpher', `elpher-go' and `elpher-bookmarks'.")
+`elpher', `elpher-go' and `elpher-bookmarks'."
+ (setq-local elpher-current-page nil)
+ (setq-local elpher-history nil)
+ (setq-local elpher-buffer-name (buffer-name)))
(when (fboundp 'evil-set-initial-state)
(evil-set-initial-state 'elpher-mode 'motion))
+;;; Menu
+;;
+
+(defun elpher-menu (&optional arg)
+ "Show a list of all your `elpher' buffers.
+With an optional argument, add all the history items, too."
+ (interactive "P")
+ (switch-to-buffer (get-buffer-create "*Elpher Menu*"))
+ (elpher-menu-mode)
+ (elpher-menu-refresh arg)
+ (tabulated-list-print))
+
+(defvar elpher-menu-mode-map
+ (let ((map (make-sparse-keymap))
+ (menu-map (make-sparse-keymap)))
+ (set-keymap-parent map tabulated-list-mode-map)
+ (define-key map "v" 'Buffer-menu-select)
+ (define-key map "2" 'Buffer-menu-2-window)
+ (define-key map "1" 'Buffer-menu-1-window)
+ (define-key map "f" 'Buffer-menu-this-window)
+ (define-key map "e" 'Buffer-menu-this-window)
+ (define-key map "\C-m" 'elpher-menu-this-window)
+ (define-key map "o" 'elpher-menu-other-window)
+ (define-key map "\C-o" 'elpher-menu-switch-other-window)
+ (define-key map "d" 'Buffer-menu-delete)
+ (define-key map "k" 'Buffer-menu-delete)
+ (define-key map "\C-k" 'Buffer-menu-delete)
+ (define-key map "\C-d" 'Buffer-menu-delete-backwards)
+ (define-key map "x" 'Buffer-menu-execute)
+ (define-key map " " 'next-line)
+ (define-key map "\177" 'Buffer-menu-backup-unmark)
+ (define-key map "u" 'Buffer-menu-unmark)
+ (define-key map "m" 'Buffer-menu-mark)
+ (define-key map "b" 'Buffer-menu-bury)
+ (define-key map (kbd "M-s a C-s") 'Buffer-menu-isearch-buffers)
+ (define-key map (kbd "M-s a M-C-s") 'Buffer-menu-isearch-buffers-regexp)
+ (define-key map (kbd "M-s a C-o") 'Buffer-menu-multi-occur)
+ (define-key map [mouse-2] 'Buffer-menu-mouse-select)
+ (define-key map [follow-link] 'mouse-face)
+ (define-key map [menu-bar elpher-menu-mode] (cons (purecopy "Elpher-Menu") menu-map))
+ (bindings--define-key menu-map [quit]
+ '(menu-item "Quit" quit-window
+ :help "Remove the elpher menu from the display"))
+ (bindings--define-key menu-map [rev]
+ '(menu-item "Refresh" revert-buffer
+ :help "Refresh the *Elpher Menu* buffer contents"))
+ (bindings--define-key menu-map [s0] menu-bar-separator)
+ (bindings--define-key menu-map [sel]
+ '(menu-item "Select Marked" Buffer-menu-select
+ :help "Select this line's buffer; also display buffers marked with `>'"))
+ (bindings--define-key menu-map [bm2]
+ '(menu-item "Select Two" Buffer-menu-2-window
+ :help "Select this line's buffer, with previous buffer in second window"))
+ (bindings--define-key menu-map [bm1]
+ '(menu-item "Select Current" Buffer-menu-1-window
+ :help "Select this line's buffer, alone, in full frame"))
+ (bindings--define-key menu-map [ow]
+ '(menu-item "Select in Other Window" elpher-menu-other-window
+ :help "Select this line's buffer in other window, leaving buffer menu visible"))
+ (bindings--define-key menu-map [tw]
+ '(menu-item "Select in Current Window" elpher-menu-this-window
+ :help "Select this line's buffer in this window"))
+ (bindings--define-key menu-map [s2] menu-bar-separator)
+ (bindings--define-key menu-map [is]
+ '(menu-item "Regexp Isearch Marked Buffers..." Buffer-menu-isearch-buffers-regexp
+ :help "Search for a regexp through all marked buffers using Isearch"))
+ (bindings--define-key menu-map [ir]
+ '(menu-item "Isearch Marked Buffers..." Buffer-menu-isearch-buffers
+ :help "Search for a string through all marked buffers using Isearch"))
+ (bindings--define-key menu-map [mo]
+ '(menu-item "Multi Occur Marked Buffers..." Buffer-menu-multi-occur
+ :help "Show lines matching a regexp in marked buffers using Occur"))
+ (bindings--define-key menu-map [s3] menu-bar-separator)
+ (bindings--define-key menu-map [by]
+ '(menu-item "Bury" Buffer-menu-bury
+ :help "Bury the buffer listed on this line"))
+ (bindings--define-key menu-map [ex]
+ '(menu-item "Execute" Buffer-menu-execute
+ :help "Delete buffers marked with k commands"))
+ (bindings--define-key menu-map [s4] menu-bar-separator)
+ (bindings--define-key menu-map [delb]
+ '(menu-item "Mark for Delete and Move Backwards" Buffer-menu-delete-backwards
+ :help "Mark buffer on this line to be deleted by x command and move up one line"))
+ (bindings--define-key menu-map [del]
+ '(menu-item "Mark for Delete" Buffer-menu-delete
+ :help "Mark buffer on this line to be deleted by x command"))
+ (bindings--define-key menu-map [umk]
+ '(menu-item "Unmark" Buffer-menu-unmark
+ :help "Cancel all requested operations on buffer on this line and move down"))
+ (bindings--define-key menu-map [mk]
+ '(menu-item "Mark" Buffer-menu-mark
+ :help "Mark buffer on this line for being displayed by v command"))
+ map)
+ "Local keymap for `elpher-menu-mode' buffers.")
+
+(define-derived-mode elpher-menu-mode tabulated-list-mode "Elpher Menu"
+ "Major mode for Elpher Menu buffers.
+The Elpher Menu is invoked by the command \\[elpher-menu]. When
+invoked with a prefix, the command also shows history items.
+Since history items are no longer showing in a buffer, many of
+the commands shown below will not work on them.
+
+In Elpher Menu mode, the following commands are defined:
+\\<elpher-menu-mode-map>
+\\[quit-window] Remove the Buffer Menu from the display.
+\\[tabulated-list-sort] Sorts buffers according to the current
+ column. With a numerical argument, sort by that column.
+\\[elpher-menu-this-window] Select current line's buffer in place of the buffer menu.
+\\[elpher-menu-other-window] Select that buffer in another window,
+ so the Buffer Menu remains visible in its window.
+\\[elpher-menu-switch-other-window] Make another window display that buffer.
+\\[Buffer-menu-mark] Mark current line's buffer to be displayed.
+\\[Buffer-menu-select] Select current line's buffer.
+ Also show buffers marked with m, in other windows.
+\\[Buffer-menu-1-window] Select that buffer in full-frame window.
+\\[Buffer-menu-2-window] Select that buffer in one window, together with the
+ buffer selected before this one in another window.
+\\[Buffer-menu-isearch-buffers] Incremental search in the marked buffers.
+\\[Buffer-menu-isearch-buffers-regexp] Isearch for regexp in the marked buffers.
+\\[Buffer-menu-multi-occur] Show lines matching regexp in the marked buffers.
+\\[Buffer-menu-delete] Mark that buffer to be deleted, and move down.
+\\[Buffer-menu-delete-backwards] Mark that buffer to be deleted, and move up.
+\\[Buffer-menu-execute] Delete or save marked buffers.
+\\[Buffer-menu-unmark] Remove all marks from current line.
+ With prefix argument, also move up one line.
+\\[Buffer-menu-backup-unmark] Back up a line and remove marks.
+\\[revert-buffer] Update the list of buffers.
+\\[Buffer-menu-bury] Bury the buffer listed on this line."
+ (add-hook 'tabulated-list-revert-hook 'elpher-menu-refresh nil t))
+
+(defun elpher-menu-this-window ()
+ "Select this line’s buffer in this window.
+Switch to the buffer, if possible. If there is no buffer, chances
+are that we're looking at a history item. Let's visit the item
+instead of complaining that their buffers have been killed."
+ (interactive)
+ (elpher-menu-handle-buffer-or-data 'switch-to-buffer))
+
+(defun elpher-menu-other-window ()
+ "Select this line’s buffer in other window, leaving buffer menu visible."
+ (interactive)
+ (elpher-menu-handle-buffer-or-data 'switch-to-buffer-other-window))
+
+(defun elpher-menu-switch-other-window ()
+ "Make the other window select this line's buffer.
+The current window remains selected."
+ (interactive)
+ (elpher-menu-handle-buffer-or-data
+ (lambda (buf) (display-buffer buf t))))
+
+(defun elpher-menu-handle-buffer-or-data (buffer-func)
+ "Handle an item in `elpher-menu-mode'.
+Determine the entry ID of the Tabulated List entry at point. If
+ID is a buffer, invoke BUFFER-FUNC on it. Otherwise, ID is a
+list (BUFFER FUNC ARGS...). Switch to BUFFER using BUFFER-FUNC
+and apply FUNC to ARGS."
+ (let ((data (tabulated-list-get-id)))
+ (cond ((bufferp data)
+ (funcall buffer-func data))
+ ((and (listp data)
+ (buffer-live-p (nth 0 data))
+ (fboundp (nth 1 data)))
+ (funcall buffer-func (nth 0 data))
+ (apply (nth 1 data) (nthcdr 2 data)))
+ (t
+ (error "There's no entry on this line of the menu")))))
+
+(defvar elpher-title nil)
+
+(defun elpher-find-title ()
+ "Return the first heading1."
+ (if elpher-title
+ elpher-title
+ (let ((start (text-property-any
+ (point-min) (point-max)
+ 'face 'elpher-gemini-heading1)))
+ (when start
+ (save-excursion
+ (goto-char start)
+ (setq-local elpher-title
+ (buffer-substring-no-properties
+ start (line-end-position))))))))
+
+(defun elpher-menu-refresh (&optional arg)
+ "Refresh the list of buffers.
+With an optional argument, add all the history items, too. Note
+that there are no buffers for history items so many of the buffer
+menu commands won't work on them."
+ (setq tabulated-list-format
+ (vector '("T" 1 t)
+ '("Name" 30 t)
+ '("URL" 40 t))
+ tabulated-list-sort-key nil)
+ ;; Collect info for each buffer we're interested in.
+ (let (entries)
+ (dolist (buf (buffer-list))
+ (with-current-buffer buf
+ (when (memq major-mode '(elpher-mode eww-mode gemini-mode))
+ (if arg
+ (setq entries (nconc (elpher-menu-refresh-history) entries))
+ (push (elpher-menu-refresh-current) entries)))))
+ (setq tabulated-list-entries (nreverse entries)))
+ (tabulated-list-init-header))
+
+(defun elpher-menu-refresh-current ()
+ "Returns an item for `elpher-menu-refresh'
+based on the current buffer.
+
+An item is a list (BUFFER VECTOR) where BUFFER is the buffer this
+item refers to and VECTOR is what to display in the tabulated
+list established by `elpher-menu-refresh'. See
+`tabulated-list-format'."
+ (list (current-buffer)
+ (cond ((eq major-mode 'elpher-mode)
+ (vector "G"
+ (or (elpher-find-title)
+ (elpher-page-display-string elpher-current-page)
+ (buffer-name))
+ (or (elpher-address-to-url
+ (elpher-page-address elpher-current-page))
+ "none")))
+ ((eq major-mode 'gemini-mode)
+ (vector "E"
+ (or (elpher-page-display-string elpher-current-page)
+ (buffer-name))
+ (or (elpher-address-to-url
+ (elpher-page-address elpher-current-page))
+ "none")))
+ ((eq major-mode 'eww-mode)
+ (vector "W"
+ (or (plist-get eww-data :title)
+ (buffer-name))
+ (or (eww-current-url)
+ "none"))))))
+
+(defun elpher-menu-refresh-history ()
+ "Return current entries for `elpher-menu-refresh'.
+This returns a list of items for the current buffer, based on the
+buffer's history.
+
+An item is a list (BUFFER VECTOR) where BUFFER is the buffer this
+item refers to and VECTOR is what to display in the tabulated
+list established by `elpher-menu-refresh'. See
+`tabulated-list-format'."
+ ;; Every section starts with the current page, followed by some
+ ;; history items, and ends with the separator.
+ (let ((separator (list nil
+ (vector "-"
+ (make-string 25 ?-)
+ (make-string 25 ?-)))))
+ (cond ((eq major-mode 'elpher-mode)
+ ;; A pair is (BUFFER-OR-DATA . PAGE) where BUFFER-OR-DTA is
+ ;; the current buffer, if possible, or list (BUFFER FUNC
+ ;; &rest ARGS) telling us which BUFFER to switch to, and
+ ;; what function to call. The last item of elpher-history
+ ;; has a nil page, so when that shows up, use the separator
+ (mapcar (lambda (pair)
+ (if (cdr pair)
+ (list (car pair)
+ (vector "G"
+ (or (elpher-page-display-string (cdr pair)) "?")
+ (or (elpher-address-to-url
+ (elpher-page-address (cdr pair))) "none")))
+ separator))
+ (cons (cons (current-buffer) elpher-current-page)
+ (mapcar (lambda (page)
+ (cons (list (current-buffer) 'elpher-visit-page page)
+ page))
+ elpher-history))))
+ ((eq major-mode 'gemini-mode)
+ ;; No history means a list of one item. Add a separator.
+ (list (list (current-buffer)
+ (vector "E"
+ (or (elpher-page-display-string elpher-current-page)
+ (buffer-name))
+ (or (elpher-address-to-url
+ (elpher-page-address elpher-current-page)))))
+ separator))
+ ((eq major-mode 'eww-mode)
+ ;; A pair is (BUFFER-OR-DATA . PAGE) where BUFFER-OR-DTA is
+ ;; the current buffer, if possible, or list (BUFFER FUNC
+ ;; &rest ARGS) telling us which BUFFER to switch to, and
+ ;; what function to call. Add the separator at the end.
+ (nconc (cons (list (current-buffer)
+ (vector "W"
+ (or (plist-get eww-data :title) "none")
+ (or (plist-get eww-data :url) "none")))
+ (mapcar (lambda (data)
+ (list
+ (list (current-buffer) 'eww-restore-history data)
+ (vector "W"
+ (or (plist-get data :title) "none")
+ (or (plist-get data :url) "none"))))
+ eww-history))
+ (list separator))))))
;;; Main start procedure
;;
;;;###autoload
-(defun elpher ()
- "Start elpher with default landing page."
- (interactive)
- (if (get-buffer "*elpher*")
- (switch-to-buffer "*elpher*")
- (switch-to-buffer "*elpher*")
- (setq elpher-current-node nil)
- (let ((start-node (elpher-make-node "Elpher Start Page"
- (elpher-make-special-address 'start))))
- (elpher-visit-node start-node)))
- "Started Elpher.") ; Otherwise (elpher) evaluates to start page string.
+(defun elpher (&optional arg)
+ "Start elpher with default landing page.
+The buffer used for Elpher sessions is determined by the value of
+‘elpher-buffer-name’. If there is already an Elpher session active in
+that buffer, Emacs will simply switch to it. Otherwise, a new session
+will begin. A numeric prefix arg (as in ‘C-u 42 M-x elpher RET’)
+switches to the session with that number, creating it if necessary. A
+nonnumeric prefix arg means to create a new session. Returns the
+buffer selected (or created)."
+ (interactive "P")
+ (let* ((name (default-value 'elpher-buffer-name))
+ (buf (cond ((numberp arg)
+ (get-buffer-create (format "%s<%d>" name arg)))
+ (arg
+ (generate-new-buffer name))
+ (t
+ (get-buffer-create name)))))
+ (pop-to-buffer-same-window buf)
+ (unless (buffer-modified-p)
+ (elpher-mode)
+ (let ((start-page (elpher-make-page "Elpher Start Page"
+ (elpher-make-special-address 'start))))
+ (elpher-visit-page start-page))
+ "Started Elpher."))); Otherwise (elpher) evaluates to start page string.
;;; elpher.el ends here