(require 'comint)
(defvar telnet-host-properties ()
"Specify which telnet program to use for particular hosts.
Each element has the form (HOSTNAME PROGRAM [LOGIN-NAME])
HOSTNAME says which machine the element applies to.
PROGRAM says which program to run, to talk to that machine.
LOGIN-NAME, which is optional, says what to log in as on that machine.")
(defvar telnet-new-line "\r")
(defvar telnet-mode-map nil)
(defvar telnet-prompt-pattern "^[^#$%>\n]*[#$%>] *")
(defvar telnet-replace-c-g nil)
(make-variable-buffer-local
(defvar telnet-remote-echoes t
"True if the telnet process will echo input."))
(make-variable-buffer-local
(defvar telnet-interrupt-string "\C-c" "String sent by C-c."))
(defvar telnet-count 0
"Number of output strings from telnet process while looking for password.")
(make-variable-buffer-local 'telnet-count)
(defvar telnet-program "telnet"
"Program to run to open a telnet connection.")
(defvar telnet-initial-count -50
"Initial value of `telnet-count'. Should be set to the negative of the
number of terminal writes telnet will make setting up the host connection.")
(defvar telnet-maximum-count 4
"Maximum value `telnet-count' can have.
After this many passes, we stop looking for initial setup data.
Should be set to the number of terminal writes telnet will make
rejecting one login and prompting again for a username and password.")
(defun telnet-interrupt-subjob ()
(interactive)
"Interrupt the program running through telnet on the remote host."
(send-string nil telnet-interrupt-string))
(defun telnet-c-z ()
(interactive)
(send-string nil "\C-z"))
(defun send-process-next-char ()
(interactive)
(send-string nil
(char-to-string
(let ((inhibit-quit t))
(prog1 (read-char)
(setq quit-flag nil))))))
(if telnet-mode-map
nil
(setq telnet-mode-map (nconc (make-sparse-keymap) comint-mode-map))
(define-key telnet-mode-map "\C-m" 'telnet-send-input)
(define-key telnet-mode-map "\C-c\C-q" 'send-process-next-char)
(define-key telnet-mode-map "\C-c\C-c" 'telnet-interrupt-subjob)
(define-key telnet-mode-map "\C-c\C-z" 'telnet-c-z))
(defun telnet-check-software-type-initialize (string)
"Tries to put correct initializations in. Needs work."
(let ((case-fold-search t))
(cond ((string-match "unix" string)
(setq telnet-prompt-pattern comint-prompt-regexp)
(setq telnet-new-line "\n"))
((string-match "tops-20" string) (setq telnet-prompt-pattern "[@>]*"))
((string-match "its" string)
(setq telnet-prompt-pattern "^[^*>\n]*[*>] *"))
((string-match "explorer" string) (setq telnet-replace-c-g ?\n))))
(setq comint-prompt-regexp telnet-prompt-pattern))
(defun telnet-initial-filter (proc string)
(save-current-buffer
(set-buffer (process-buffer proc))
(let ((case-fold-search t))
(cond ((string-match "No such host" string)
(kill-buffer (process-buffer proc))
(error "No such host"))
((string-match "passw" string)
(telnet-filter proc string)
(setq telnet-count 0)
(send-string proc (concat (comint-read-noecho "Password: " t)
telnet-new-line))
(clear-this-command-keys))
(t (telnet-check-software-type-initialize string)
(telnet-filter proc string)
(cond ((> telnet-count telnet-maximum-count)
(set-process-filter proc 'telnet-filter))
(t (setq telnet-count (1+ telnet-count)))))))))
(defun telnet-simple-send (proc string)
(comint-send-string proc string)
(comint-send-string proc telnet-new-line))
(defun telnet-filter (proc string)
(save-excursion
(set-buffer (process-buffer proc))
(let* ((last-insertion (marker-position (process-mark proc)))
(delta (- (point) last-insertion))
(ie (and comint-last-input-end
(marker-position comint-last-input-end)))
(w (get-buffer-window (current-buffer)))
(ws (and w (window-start w))))
(goto-char last-insertion)
(insert-before-markers string)
(set-marker comint-last-output-start last-insertion)
(set-marker (process-mark proc) (point))
(if ws (set-window-start w ws t))
(if ie (set-marker comint-last-input-end ie))
(while (progn (skip-chars-backward "^\C-m" last-insertion)
(> (point) last-insertion))
(delete-region (1- (point)) (point)))
(goto-char (process-mark proc))
(and telnet-replace-c-g
(subst-char-in-region last-insertion (point) ?\C-g
telnet-replace-c-g t))
(if (> delta 0)
(goto-char (+ (process-mark proc) delta))))))
(defun telnet-send-input ()
(interactive)
(comint-send-input)
(if telnet-remote-echoes
(delete-region comint-last-input-start
comint-last-input-end)))
(defun telnet (host)
"Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer `*PROGRAM-HOST*'
where PROGRAM is the telnet program being used. This program
is controlled by the contents of the global variable `telnet-host-properties',
falling back on the value of the global variable `telnet-program'.
Normally input is edited in Emacs and sent a line at a time."
(interactive "sOpen connection to host: ")
(let* ((comint-delimiter-argument-list '(?\ ?\t))
(properties (cdr (assoc host telnet-host-properties)))
(telnet-program (if properties (car properties) telnet-program))
(name (concat telnet-program "-" (comint-arguments host 0 nil) ))
(buffer (get-buffer (concat "*" name "*")))
(telnet-options (if (cdr properties) (cons "-l" (cdr properties))))
process)
(if (and buffer (get-buffer-process buffer))
(pop-to-buffer (concat "*" name "*"))
(pop-to-buffer
(apply 'make-comint name telnet-program nil telnet-options))
(setq process (get-buffer-process (current-buffer)))
(set-process-filter process 'telnet-initial-filter)
(accept-process-output process)
(erase-buffer)
(send-string process (concat "open " host "\n"))
(telnet-mode)
(setq comint-input-sender 'telnet-simple-send)
(setq telnet-count telnet-initial-count))))
(put 'telnet-mode 'mode-class 'special)
(defun telnet-mode ()
"This mode is for using telnet (or rsh) from a buffer to another host.
It has most of the same commands as comint-mode.
There is a variable ``telnet-interrupt-string'' which is the character
sent to try to stop execution of a job on the remote host.
Data is sent to the remote host when RET is typed.
\\{telnet-mode-map}
"
(interactive)
(comint-mode)
(setq major-mode 'telnet-mode
mode-name "Telnet"
comint-prompt-regexp telnet-prompt-pattern)
(use-local-map telnet-mode-map)
(run-hooks 'telnet-mode-hook))
(defun rsh (host)
"Open a network login connection to host named HOST (a string).
Communication with HOST is recorded in a buffer `*rsh-HOST*'.
Normally input is edited in Emacs and sent a line at a time."
(interactive "sOpen rsh connection to host: ")
(require 'shell)
(let ((name (concat "rsh-" host )))
(pop-to-buffer (make-comint name remote-shell-program nil host))
(set-process-filter (get-process name) 'telnet-initial-filter)
(telnet-mode)
(setq telnet-count -16)))
(provide 'telnet)