Anonymous avatar Anonymous committed 4e9b09b

EFS 1.24

Comments (0)

Files changed (42)

-2004-10-04  Norbert Koch  <viteno@xemacs.org>
+2007-10-10  Michael Sperber  <sperber@deinprogramm.de>
 
-	* Makefile (VERSION): XEmacs package 1.33 released.
+	* EFS 1.24.
+
+2007-08-27  Michael Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs-cu.el (efs): 
+	(efs-behavior): 
+	(efs-auto-save): 
+	(efs-gateways): 
+	(efs-programs): 
+	(efs-parameters): 
+	(efs-hooks): Move these customization groups from efs.el.
+	(efs-vms-host-regexp): 
+	(efs-cms-host-regexp): 
+	(efs-mts-host-regexp): 
+	(efs-ti-explorer-host-regexp): 
+	(efs-ti-twenex-host-regexp): 
+	(efs-sysV-unix-host-regexp): 
+	(efs-bsd-unix-host-regexp): 
+	(efs-next-unix-host-regexp): 
+	(efs-unix-host-regexp): 
+	(efs-dumb-unix-host-regexp): 
+	(efs-super-dumb-unix-host-regexp): 
+	(efs-dos-host-regexp): 
+	(efs-apollo-unix-host-regexp): 
+	(efs-mvs-host-regexp): 
+	(efs-tops-20-host-regexp): 
+	(efs-mpe-host-regexp): 
+	(efs-ka9q-host-regexp):
+	(efs-dos-distinct-host-regexp): 
+	(efs-os2-host-regexp): 
+	(efs-vos-host-regexp): 
+	(efs-hell-host-regexp): 
+	(efs-guardian-host-regexp): 
+	(efs-ms-unix-host-regexp): 
+	(efs-plan9-host-regexp): 
+	(efs-cms-knet-host-regexp): 
+	(efs-nos-ve-host-regexp): 
+	(efs-netware-host-regexp): 
+	(efs-dumb-apollo-unix-regexp): Customize.
+
+2007-08-21  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs.el (efs-skip-msgs-alist): Ignore IPv6 "No route to host"
+	error messages from the client.
+
+2007-05-10  Noah Friedman  <friedman@splode.com>
+
+	* efs.el (efs-require): Handle extra arguments beyond feature and
+	filename portably.  Emacs 22 has 'noerror' argument.
+
+	* efs-netrc.el (efs-root-file-name-completion): Handle optional
+	arg `predicate' for Emacs 22.
+
+2007-02-05  Michael Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs-dired.el (efs-dired-copy-file): Enable recursive copying.
+
+2007-01-03  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs.el (efs-month-and-time-regexp): Copy change for Breton month
+	names from Dired.
+
+2006-04-12  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs.el (efs-ftp-explicit-empty-file-name): Add, to handle
+	*BSD-specific kludge for ftp clients that don't accept an explicit
+	empty file name.
+
+2005-04-09  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs.texi (Getting help): Note new mailing list.
+
+	* efs-report.el (efs-bug-address): New mailing list.
+
+	* efs.el (efs-process-scream-and-yell)
+	(efs-require-scream-and-yell): New mailing list.
+
+2005-01-14  Steve Youngs  <steve@sxemacs.org>
+
+	* efs-fnh.el (efs-handle-emacs-version): Use `emacs-*-version'
+	variables for version info instead of string-matching through
+	`emacs-version'.
+
+2005-01-23  Timothy OCallaghan <T.OCallaghan@elsevier.com>.
+
+	* efs-vms.el (efs-fix-path):
+	(efs-fix-dir-path): Make EFS work better for VMS hosts.
+
+2005-01-23  Michael Sperber  <sperber@informatik.uni-tuebingen.de>
+
+	* efs.el (efs-send-cmd): Kludge addition for VMS, based on a patch
+	by Timothy OCallaghan <T.OCallaghan@elsevier.com>.
 
 2004-10-02  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
 
 2003-08-07  Mike Sperber  <sperber@informatik.uni-tuebingen.de>
 
 	* efs.el (efs-month-and-time-regexp): Rewrite to match Dired.
-	(efs-file-size-submatch): 
-	(efs-month-date-submatch): 
+	(efs-file-size-submatch):
+	(efs-month-date-submatch):
 	(efs-time-or-year-submatch): Add.
 	(efs-month-regexp-alist): Replaces `efs-month-alist'.  Should
 	handle lotsa more languages than before.
 
 2002-09-05  Katsumi Yamaoka  <yamaoka@jpl.org>
 
-	* efs.el (efs-load): 
+	* efs.el (efs-load):
 	(efs-require): Make `eval-after-load' work.
 
 2002-09-01  Michael Sperber [Mr. Preprocessor]  <sperber@informatik.uni-tuebingen.de>
 
 2002-08-27  Michael Sperber [Mr. Preprocessor]  <sperber@informatik.uni-tuebingen.de>
 
-	* efs-guardian.el (efs-fix-path): 
+	* efs-guardian.el (efs-fix-path):
 	(efs-split-guardian-path):
 	(efs-guardian-file-name-nondirectory):
 	(efs-fix-dir-path): Rewrite Guardian path handling based on
 
 2002-04-13  Jonathan Harris <jhar@tardis.ed.ac.uk>
 
-	* efs-dired.el (efs-dired-compress-file): 
-	* efs.el (efs-recover-file): 
+	* efs-dired.el (efs-dired-compress-file):
+	* efs.el (efs-recover-file):
 	* efs-cu.el (efs-chase-symlinks): Force proper use of
 	`efs-file-symlink-p'.
 
 2002-04-13  Bob Weiner <weiner@altrasoft.com>
 
-	* efs.el: 
+	* efs.el:
 	(efs-wipe-from-ls-cache):
 	(efs-substitute-in-file-name):
 	(efs-file-name-as-directory):
 
 2002-04-13  Michael Sperber [Mr. Preprocessor]  <sperber@informatik.uni-tuebingen.de>
 
-	* efs.el (efs-file-regular-p): 
-	(efs-internal-file-regular-p): 
+	* efs.el (efs-file-regular-p):
+	(efs-internal-file-regular-p):
 	* efs-guardian.el (efs-internal-file-regular-p): Added
 	`file-regular-p' for remote files.
 
 1998-10-27  Jan Vroonhof  <vroonhof@math.ethz.ch>
 
 	* efs.el: Require comint softly. Provide dummy if not
-		available (bare XEmacs)	
-	
-	* efs-netrc.el: Do not require passwd. Use autoload. 
+		available (bare XEmacs)
+
+	* efs-netrc.el: Do not require passwd. Use autoload.
 
 1999-10-19  Kirat Singh <singhki@jany.gs.com>
 
 
 1998-03-14  Michael Sperber [Mr. Preprocessor]  <sperber@informatik.uni-tuebingen.de>
 
-	* efs-dump.el: Pulled in necessary variables and autoloads. 
+	* efs-dump.el: Pulled in necessary variables and autoloads.
 
 	* dumped-lisp.el: Created.
 
 	* efs.el, efs-tops-20.el, efs-vos.el, efs-pc.el, efs-netware.el, efs-nos-ve.el, efs-mts.el, efs-mvs.el, efs-netrc.el, efs-mpe.el, efs-ms-unix.el, efs-hell.el, efs-ka9q.el, efs-dos-distinct.el, efs-guardian.el, efs-dired.el, efs-dl.el, efs-cms.el:
 	Remove preceding-char & following-char.
 
-	
+
 1997-04-25  Michael Sperber [Mr. Preprocessor]  <sperber@informatik.uni-tuebingen.de>
 
 	* efs.texi: Directory entry.
-There are several mailing lists relevant to efs.  If you wish to join
-a list, send e-mail to their -request address.
+The EFS mailing list discusses all aspects of EFS.  You can send
+messages to the list at
 
-  efs-bugs@hplb.hpl.hp.com
+elisp-code-efs@nongnu.org
 
-This is where all bug reports should go.  M-x efs-report-bug is the
-recommended way of sending bug reports about efs, and this will send by
-default to this address.
+You can subscribe, view the archives, and perform a number of other
+adminstrative tasks at:
 
-  efs-help@hplb.hpl.hp.com
-
-This is where general discussions about efs should go.  For beta-testing
-discussions, use efs-testers instead.
-
-  efs-testers@hplb.hpl.hp.com
-
-This is where discussions about beta testing efs should go.  Bugs should
-however be reported to efs-bugs. Patches for beta test bugs will be
-sent to this list.
-
-  efs-announce@hplb.hpl.hp.com
-
-This is where announcements such as new generally available releases of efs
-should go.
-
-Each of the lists have a -request address to join and leave the list.
+http://lists.nongnu.org/mailman/listinfo/elisp-code-efs
 include Makefile.efs
 
 VERSION = 1.33
-AUTHOR_VERSION = 1.23
+AUTHOR_VERSION = 1.24
 MAINTAINER = Mike Sperber <sperber@informatik.uni-tuebingen.de>
 PACKAGE = efs
 PKG_TYPE = regular
 ###############################################################################
 #
 # File:         Makefile
-# Release:      $EFS release: 1.23 $
+# Release:      $EFS release: 1.24 $
 # Release:      $dired release: 7.11 $
 # Version:      #Revision: 1.9 $
 # RCS:
-This is EFS 1.23
+This is EFS 1.24
 ================
 
 EFS is a system for transparent file-transfer between remote VMS, CMS,
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-auto.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.8 $
 ;; RCS:          
 ;; Description:  Simple way of autoloading efs
 (require 'efs-fnh)
 
 (defconst efs-auto-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.8 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-cms-knet.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  CMS support for efs using KNET/VM server
 (require 'efs)
 
 (defconst efs-cms-knet-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-cms.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.9 $
 ;; RCS:          
 ;; Description:  CMS support for efs
 (require 'efs)
 
 (defconst efs-cms-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.9 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-coke.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Coke Machine support for efs
 (require 'efs)
 
 (defconst efs-coke-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-cp-p.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:          
 ;; Description:  Support for preserving file modtimes with copies. i.e. cp -p
 ;;;; Internal Variables
 
 (defconst efs-cp-p-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-cu.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.13 $
 ;; RCS:          
 ;; Description:  Common utilities needed by efs files.
 ;;;; Provisions and autoloads.
 
 (provide 'efs-cu)
+(require 'custom)
 (require 'backquote)
 (autoload 'efs-get-process "efs")
 (autoload 'efs-parse-netrc "efs-netrc")
 ;;;; -------------------------------------------------------------
 
 (defconst efs-cu-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.13 $" 11 -2)))
 
 ;; the part of the path to the left of this pattern.
 
 ;;;; -----------------------------------------------------------
+;;;; Customization groups
+;;;; -----------------------------------------------------------
+
+(defgroup efs nil
+  "Transparent ftp access."
+  :group 'files)
+
+(defgroup efs-behavior nil
+  "User-visible aspects of EFS."
+  :prefix "efs-"
+  :group 'efs)
+
+(defgroup efs-auto-save nil
+  "EFS interaction with auto-save."
+  :prefix "efs-"
+  :group 'efs)
+
+(defgroup efs-gateways nil
+  "Using EFS via an ftp gateway."
+  :prefix "efs-"
+  :group 'efs)
+
+(defgroup efs-programs nil
+  "External programs used by EFS."
+  :prefix "efs-"
+  :group 'efs)
+
+(defgroup efs-parameters nil
+  "Behind-the-scenes parameters of EFS."
+  :prefix "efs-"
+  :group 'efs)
+
+(defgroup efs-hooks nil
+  "Hooks for EFS."
+  :prefix "efs-"
+  :group 'efs)
+
+;;;; -----------------------------------------------------------
 ;;;; Variables for multiple host type support
 ;;;; -----------------------------------------------------------
 
-(defvar efs-vms-host-regexp nil
-  "Regexp to match the names of hosts running VMS.")
-(defvar efs-cms-host-regexp nil
-  "Regexp to match the names of hosts running CMS.")
-(defvar efs-mts-host-regexp nil
-  "Regexp to match the names of hosts running MTS.")
-(defvar efs-ti-explorer-host-regexp nil
+(defcustom efs-vms-host-regexp nil
+  "Regexp to match the names of hosts running VMS."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-cms-host-regexp nil
+  "Regexp to match the names of hosts running CMS."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-mts-host-regexp nil
+  "Regexp to match the names of hosts running MTS."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-ti-explorer-host-regexp nil
   "Regexp to match the names of hosts running TI-EXPLORER.
-These are lisp machines.")
-(defvar efs-ti-twenex-host-regexp nil
+These are lisp machines."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-ti-twenex-host-regexp nil
   "Regexp to match the names of hosts running TI-TWENEX.
-These are lisp machines, and this should not be confused with DEC's TOPS-20.")
-(defvar efs-sysV-unix-host-regexp nil
+These are lisp machines, and this should not be confused with DEC's TOPS-20."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-sysV-unix-host-regexp nil
   "Regexp to match the names of sysV unix hosts.
 These are defined to be unix hosts which mark symlinks
-with a @ in an ls -lF listing.")
-(defvar efs-bsd-unix-host-regexp nil
+with a @ in an ls -lF listing."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-bsd-unix-host-regexp nil
   "Regexp to match the names of bsd unix hosts.
 These are defined to be unix hosts which do not mark symlinks
-with a @ in an ls -lF listing.")
-(defvar efs-next-unix-host-regexp nil
+with a @ in an ls -lF listing."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-next-unix-host-regexp nil
   "Regexp to match names of NeXT unix hosts.
 These are defined to be unix hosts which put a @ after the
-destination of a symlink when doing ls -lF listing.")
-(defvar efs-unix-host-regexp nil
+destination of a symlink when doing ls -lF listing."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-unix-host-regexp nil
   "Regexp to match names of unix hosts.
-I you know which type of unix, it is much better to set that regexp instead.")
-(defvar efs-dumb-unix-host-regexp nil
+I you know which type of unix, it is much better to set that regexp instead."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-dumb-unix-host-regexp nil
   "Regexp to match names of unix hosts which do not take ls switches.
-For these hosts we use the \"dir\" command.")
-(defvar efs-super-dumb-unix-host-regexp nil
+For these hosts we use the \"dir\" command."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-super-dumb-unix-host-regexp nil
   "Regexp to match names of unix hosts with FTP servers that cannot do a PWD.
 It is also assumed that these hosts do not accept ls switches, whether
-or not this is actually true.")
-(defvar efs-dos-host-regexp nil
-  "Regexp to match names of hosts running DOS.")
+or not this is actually true."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-dos-host-regexp nil
+  "Regexp to match names of hosts running DOS."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
 ;; In principal there is apollo unix support -- at least efs
 ;; should do the right thing. However, apollo ftp servers can be
 ;; very flakey, especially about accessing files by fullpaths.
 ;; Good luck.
-(defvar efs-apollo-unix-host-regexp nil
+(defcustom efs-apollo-unix-host-regexp nil
   "Regexp to match names of apollo unix hosts running Apollo's Domain.
 For these hosts we don't short-circuit //'s immediately following 
-\"/user@host:\"")
-(defvar efs-mvs-host-regexp nil
-  "Regexp to match names of hosts running MVS.")
-(defvar efs-tops-20-host-regexp nil
-  "Regexp to match names of hosts runninf TOPS-20.")
-(defvar efs-mpe-host-regexp nil
-  "Regexp to match hosts running the MPE operating system.")
-(defvar efs-ka9q-host-regexp nil
+\"/user@host:\""
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-mvs-host-regexp nil
+  "Regexp to match names of hosts running MVS."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-tops-20-host-regexp nil
+  "Regexp to match names of hosts runninf TOPS-20."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-mpe-host-regexp nil
+  "Regexp to match hosts running the MPE operating system."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-ka9q-host-regexp nil
   "Regexp to match hosts using the ka9q ftp server. 
-These may actually be running one of DOS, LINUX, or unix.")
-(defvar efs-dos-distinct-host-regexp nil
+These may actually be running one of DOS, LINUX, or unix."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-dos-distinct-host-regexp nil
   "Regexp to match DOS hosts using the Distinct FTP server.
 These are not treated as DOS hosts with a special listing format, because
-the Distinct FTP server uses unix-style path syntax.")
-(defvar efs-os2-host-regexp nil
-  "Regexp to match names of hosts running OS/2.")
-(defvar efs-vos-host-regexp nil
-  "Regexp to match hosts running the VOS operating system.")
-(defvar efs-hell-host-regexp nil
+the Distinct FTP server uses unix-style path syntax."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-os2-host-regexp nil
+  "Regexp to match names of hosts running OS/2."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-vos-host-regexp nil
+  "Regexp to match hosts running the VOS operating system."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-hell-host-regexp nil
   "Regexp to match hosts using the hellsoft ftp server.
-These map be either DOS PC's or Macs.")
+These map be either DOS PC's or Macs."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
 ;; The way that we implement the hellsoft support, it probably won't
 ;; work with Macs. This could probably be fixed, if enough people scream.
-(defvar efs-guardian-host-regexp nil
-  "Regexp to match hosts running Tandem's guardian operating system.")
+(defcustom efs-guardian-host-regexp nil
+  "Regexp to match hosts running Tandem's guardian operating system."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
 ;; Note that ms-unix is really an FTP server running under DOS.
 ;; It's not a type of unix.
-(defvar efs-ms-unix-host-regexp nil
-  "Regexp to match hosts using the Microsoft FTP server in unix mode.")
-(defvar efs-plan9-host-regexp nil
-  "Regexp to match hosts running ATT's Plan 9 operating system.")
-(defvar efs-cms-knet-host-regexp nil
-  "Regexp to match hosts running the CMS KNET FTP server.")
-(defvar efs-nos-ve-host-regexp nil
-  "Regexp to match hosts running NOS/VE.")
-(defvar efs-netware-host-regexp nil
-  "Regexp to match hosts running Novell Netware.")
-(defvar efs-dumb-apollo-unix-regexp nil
+(defcustom efs-ms-unix-host-regexp nil
+  "Regexp to match hosts using the Microsoft FTP server in unix mode."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-plan9-host-regexp nil
+  "Regexp to match hosts running ATT's Plan 9 operating system."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-cms-knet-host-regexp nil
+  "Regexp to match hosts running the CMS KNET FTP server."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-nos-ve-host-regexp nil
+  "Regexp to match hosts running NOS/VE."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-netware-host-regexp nil
+  "Regexp to match hosts running Novell Netware."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
+(defcustom efs-dumb-apollo-unix-regexp nil
   "Regexp to match dumb hosts running Apollo's Domain.
-These are hosts which do not accept switches to ls over FTP.")
+These are hosts which do not accept switches to ls over FTP."
+  :group 'efs-parameters
+  :type '(choice (const nil) regexp))
 
 ;;; Further host types:
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-defun.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  efs-defun allows for OS-dependent coding of functions
 ;;; Variables
 
 (defconst efs-defun-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 

efs-dired-mule.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-dired.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:          
 ;; Description:  Makes efs-dired.el work with MULE.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defconst efs-dired-mule-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.2 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-dired.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.32 $
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.33 $
 ;; RCS:          
 ;; Description:  Extends much of Dired to work under efs.
 ;; Authors:      Sebastian Kremer <sk@thp.uni-koeln.de>, 
 (autoload 'dired-shell-call-process "dired-shell")
 
 (defconst efs-dired-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.32 $" 11 -2)))
 
   ;; Version of dired-copy-file for remote files.
   ;; Assumes that filenames are already expanded.
   (dired-handle-overwrite to)
-  (efs-copy-file-internal from (efs-ftp-path from) to (efs-ftp-path to)
-			  ok-flag dired-copy-preserve-time 0 cont nowait))
-
+  (let ((efs-dired-copy-file-cont
+	 (efs-cont (from to ok-flag preserve-time) (cont nowait)
+	   (efs-copy-file-internal from (efs-ftp-path from) to (efs-ftp-path to)
+				   ok-flag dired-copy-preserve-time 0 cont nowait))))     
+    (dired-copy-file-recursive 
+     (function
+      (lambda (from to ok-flag preserve-time)
+	(efs-call-cont efs-dired-copy-file-cont from to ok-flag preserve-time)))
+     from to ok-flag dired-copy-preserve-time t)))
+  
 (defun efs-dired-rename-file (from to ok-flag &optional cont nowait
 				   insert-subdir)
   ;; Version of dired-rename-file for remote files.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-dl.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.3 $
 ;; RCS:          
 ;; Description:  Unix descriptive listing support for efs
 (require 'efs)
 
 (defconst efs-dl-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.3 $" 11 -2)))
 

efs-dos-distinct.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-dos-distinct.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Distinct's DOS FTP server support for efs
 (require 'efs)
 
 (defconst efs-dos-distinct-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-dump.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:
 ;; Description:  Install a bare-bones EFS hook into file-name-handler-alist
 (provide 'efs-dump)
 
 (defconst efs-dump-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.2 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-fnh.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.4 $
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.5 $
 ;; RCS:
 ;; Description:  Look for the emacs version, and install into
 ;;               the file-name-handler-alist
 (provide 'efs-fnh)
 
 (defconst efs-fnh-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.4 $" 11 -2)))
 
   (let ((ehev-match-data (match-data)))
     (unwind-protect
 	(let ((xemacsp (string-match "XEmacs" emacs-version))
-	      ver subver)
-	  (or (string-match "^\\([0-9]+\\)\\.\\([0-9]+\\)" emacs-version)
-	      (error "efs does not work with emacs version %s" emacs-version))
-	  (setq ver (string-to-int (substring emacs-version
-					      (match-beginning 1)
-					      (match-end 1)))
-		subver (string-to-int (substring emacs-version
-						 (match-beginning 2)
-						 (match-end 2))))
+	      (ver emacs-major-version)
+	      (subver emacs-minor-version))
+	  (unless ver
+	    (or (string-match "^\\([0-9]+\\)\\.\\([0-9]+\\)" emacs-version)
+		(error "efs does not work with emacs version %s" emacs-version))
+	    (setq ver (string-to-int (substring emacs-version
+						(match-beginning 1)
+						(match-end 1)))
+		  subver (string-to-int (substring emacs-version
+						   (match-beginning 2)
+						   (match-end 2)))))
 	  (cond
 	   
 	   ;; XEmacs (emacs-version looks like \"19.xx XEmacs\")
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-guardian.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.10 $
 ;; Description:  Guardian support for efs
 ;; Author:       Sandy Rutherford <sandy@math.ubc.ca>
 ;;; questions and debugging. Thanks.
 
 (defconst efs-guardian-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.9 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-gwp.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Support for efs to use an interactive gateway.
 ;;; Internal Variables
 
 (defconst efs-gwp-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-hell.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Hellsoft FTP server support for efs
 (require 'efs)
 
 (defconst efs-hell-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-ka9q.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:          
 ;; Description:  KA9Q support for efs
 (require 'efs)
 
 (defconst efs-ka9q-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.2 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-kerberos.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:
 ;; Description:  Support for Kerberos gateways.
 (require 'efs)
 
 (defconst efs-kerberos-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-mpe.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.8 $
 ;; RCS:          
 ;; Description:  MPE (HP3000) support for efs.
 ;;; Internal Variables
 
 (defconst efs-mpe-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.8 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-ms-unix.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  efs support for the Microsoft PC FTP server in unix mode.
 (require 'efs)
 
 (defconst efs-ms-unix-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-mts.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  MTS support for efs
 (require 'efs)
 
 (defconst efs-mts-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-mvs.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.4 $
 ;; RCS:          
 ;; Description:  MVS support for efs
 (require 'efs)
 
 (defconst efs-mvs-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.4 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-netrc.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.4 $
-;; RCS:          
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.5 $
+;; RCS:
 ;; Description:  Parses ~/.netrc file, and does completion in /.
 ;; Author:       Sandy Rutherford <sandy@ibm550.sissa.it>
 ;; Created:      Fri Jan 28 19:32:47 1994 by sandy on ibm550
 ;;;; ------------------------------------------------------------
 
 (defconst efs-netrc-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.4 $" 11 -2)))
 
 
 (defun efs-parse-netrc-group (&optional machine)
   ;; Extract the values for the tokens  "machine", "login", "password",
-  ;; "account" and "minidisk"  in the current buffer.  If successful, 
+  ;; "account" and "minidisk"  in the current buffer.  If successful,
   ;; record the information found.
   (let (data login)
     ;; Get a machine token.
 
 
 ;;;###autoload
-(defun efs-root-file-name-completion (file dir)
+(defun efs-root-file-name-completion (file dir &optional predicate)
   ;; Calculates completions in the root directory to include remote hosts.
   (let ((file-name-handler-alist (efs-file-name-handler-alist-sans-fn
 				  'efs-root-handler-function)))
     (try-completion
      file
      (nconc (efs-generate-root-prefixes)
-	    (mapcar 'list (file-name-all-completions file "/"))))))
-
+            (mapcar 'list (if predicate
+                              (file-name-all-completions file "/" predicate)
+                            (file-name-all-completions file "/")))))))
 
 ;;; end of efs-netrc.el
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-netware.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.5 $
 ;; RCS:          
 ;; Description:  efs support for the Novell Netware FTP server
 (require 'efs)
 
 (defconst efs-netware-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.5 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-nos-ve.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:          
 ;; Description:  efs support for NOS/VE
 ;;; providing imformation and testing.
 
 (defconst efs-nos-ve-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.2 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-ovwrt.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.3 $
 ;; RCS:
 ;; Description:  Utilities for overwriting functions with new definitions.
     (error)))
 
 (defconst efs-ovwrt-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.3 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-pc.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  PC support for efs
 (require 'efs)
 
 (defconst efs-pc-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-plan9.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  efs support for the Plan 9 FTP Server
 (require 'efs)
 
 (defconst efs-plan9-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-report.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.10 $
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.11 $
 ;; RCS:          
 ;; Description:  Function to report efs bugs in a usable way.
 ;; Author:       Andy Norman, Dawn
 ;;; Variables
 
 (defconst efs-report-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.10 $" 11 -2)))
 
    "Fellow efs'ers:"
    "Greetings earthlings:"])
 
-(defvar efs-bug-address "efs-bugs@hplb.hpl.hp.com")
+(defvar efs-bug-address "elisp-code-efs@nongnu.org")
 
 (defconst efs-report-other-vars
   ;; List of variables needed for efs-report, that aren't generated below.

efs-ti-explorer.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-ti-explorer.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Explorer support for efs
 (require 'efs)
 
 (defconst efs-ti-explorer-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-ti-twenex.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  Support for a TI lisp machine in Twenex emulation mode.
 (require 'efs)
 
 (defconst efs-ti-twenex-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-tops-20.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Description:  TOPS-20 support for efs
 (provide 'efs-tops-20)
 
 (defconst efs-tops-20-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-vms.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.13 $
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.14 $
 ;; RCS:          
 ;; Description:  VMS support for efs
 ;; Authors:      Andy Norman, Joe Wells, Sandy Rutherford <sandy@itp.ethz.ch>
 (require 'efs)
 
 (defconst efs-vms-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.13 $" 11 -2)))
 
 	      (if (<= len 0)
 		  (setq dir nil)
 		(while (<= n len)
-		  (and (char-equal (aref dir n) ?/)
+		  (and (or (char-equal (aref dir n) ?/)
+                           (char-equal (aref dir n) ?\\)
+                           )
 		       (cond
 			((zerop n) (aset dir n ?\[))
 			((= n len) (aset dir n ?\]))
 		  (setq n (1+ n))))))
 	(concat drive dir file)))))
 
-;; It is important that this function barf for directories for which we know
-;; that we cannot possibly get a directory listing, such as "/" and "/DEV:/".
-;; This is because it saves an unnecessary FTP error, or possibly the listing
-;; might succeed, but give erroneous info. This last case is particularly
-;; likely for OS's (like MTS) for which we need to use a wildcard in order
-;; to list a directory.
+;; in vms the paths "/" and "/DEV:/" correspond to [000000] and dev:[000000]
+;; though you may not have permissions for these directories, if you do,
+;; then it mans you can explore the directory tree, rather than guess 
+;; subdirectory names
 
 (efs-defun efs-fix-dir-path vms (dir-path)
   ;; Convert path from UNIX-ish to VMS ready for a DIRectory listing.
   ;; think so, because expand-filename should have already short-circuited
   ;; them.
   (cond ((string-equal dir-path "/")
-	 (error "Cannot get listing for fictitious \"/\" directory."))
-	((string-match "^/[-A-Z0-9_$]+:/$" dir-path)
-	 (error "Cannot get listing for device."))
+	 (efs-fix-path 'vms "/000000/"))
+	((string-match "^\\(/[-A-Z0-9_$]+:/\\)$" dir-path)
+	 (efs-fix-path 'vms (concat dir-path "000000/")))
 	((efs-fix-path 'vms dir-path))))
-  
+;
+
 ;; These parsing functions are as general as possible because the syntax
 ;; of ftp listings from VMS hosts is a bit erratic. What saves us is that
 ;; the VMS filename syntax is so rigid. If they bomb on a listing in the
 ;;
 ;; File:         efs-vos.el
 ;; Description:  VOS support for efs
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.1 $
 ;; RCS:          
 ;; Author:       Sandy Rutherford <sandy@ibm550.sissa.it>
 (require 'efs)
 
 (defconst efs-vos-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.1 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs-x19.15.el
-;; Release:      $efs release: 1.23 $
+;; Release:      $efs release: 1.24 $
 ;; Version:      #Revision: 1.2 $
 ;; RCS:          
 ;; Description:  efs support for XEmacs, versions 19.15, and later.
 (require 'efs-ovwrt)
 
 (defconst efs-x19\.15-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.2 $" 11 -2)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:         efs.el
-;; Release:      $efs release: 1.23 $
-;; Version:      #Revision: 1.92 $
-;; RCS:          
+;; Release:      $efs release: 1.24 $
+;; Version:      #Revision: 1.93 $
+;; RCS:
 ;; Description:  Transparent FTP support for the original GNU Emacs
 ;;               from FSF and XEmacs
 ;; Authors:      Andy Norman <ange@hplb.hpl.hp.com>,
 ;;               Sandy Rutherford <sandy@ibm550.sissa.it>
-;;               Mike Sperber <sperber@informatik.uni-tuebingen.de> 
+;;               Mike Sperber <sperber@informatik.uni-tuebingen.de>
 ;; Created:      Thu Oct 12 14:00:05 1989 (as ange-ftp)
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; The following restrictions apply to all of the files in the efs
 ;;; distribution.
-;;; 
+;;;
 ;;; Copyright (C) 1993  Andy Norman / Sandy Rutherford
 ;;; Copyright (C) 2003  Mike Sperber
 ;;;
 ;;; Authors:
 ;;;          Andy Norman (ange@hplb.hpl.hp.com)
 ;;;          Sandy Rutherford (sandy@ibm550.sissa.it)
-;;;          
+;;;
 ;;;          The authors of some of the sub-files of efs are different
 ;;;          from the above.  We are very grateful to people who have
 ;;;          contributed code to efs.
 ;;; substitute-in-file-name
 ;;; verify-visited-file-modtime
 ;;; write-region
-;;; 
+;;;
 ;;; The following functions are overloaded in efs.el, because they cannot
 ;;; be handled via the file-name-handler-alist.
 ;;;
 ;;; load
 ;;; read-file-name-internal (Emacs 18, only)
 ;;; require
-;;; 
+;;;
 ;;; The following dired functions are handled by hooking them into the
 ;;; the file-name-handler-alist. This is done in efs-dired.el.
-;;; 
+;;;
 ;;; efs-dired-compress-file
 ;;; eds-dired-print-file
 ;;; efs-dired-make-compressed-filename
 ;;; efs-dired-recursive-delete-directory
 ;;; efs-dired-uncache
 ;;; efs-dired-call-process
-;;; 
+;;;
 ;;; In efs-dired.el, the following dired functions are overloaded.
 ;;;
 ;;; dired-collect-file-versions
 ;;; dired-grep-load-hook
 
 ;;; LISPDIR ENTRY for the Elisp Archive:
-;;; 
+;;;
 ;;;    LCD Archive Entry:
 ;;;    efs|Andy Norman and Sandy Rutherford
 ;;;    |ange@hplb.hpl.hp.com and sandy@ibm550.sissa.it
 ;;;    |transparent FTP Support for GNU Emacs
-;;;    |$Date$|$efs release: 1.23 $|
+;;;    |$Date$|$efs release: 1.24 $|
 
 ;;; Host and listing type notation:
 ;;;
 ;;; Host and listing type hierarchy:
 ;;;
 ;;; unknown: unix, dumb-unix, sysV-unix, bsd-unix, next-unix, apollo-unix,
-;;;          ka9q, dos-distinct, unix:dl, hell, 
+;;;          ka9q, dos-distinct, unix:dl, hell,
 ;;;          super-dumb-unix, dumb-apollo-unix
 ;;; unix:    sysV-unix, bsd-unix, next-unix, apollo-unix, unix:dl
 ;;; dos:     dos:ftp, dos:novell, dos:ncsa, dos:microsoft, dos:winsock
 ;;; plan9:
 ;;; nos-ve:
 ;;; coke:
-;;; 
+;;;
 
 
 ;;;; ================================================================
 ;; When bootstapping XEmacs, comint is not available
 (condition-case nil
     (require 'comint)
-  (error 
+  (error
    (defun comint-mode ()
      (fundamental-mode))
    (defun comint-output-filter (process string)
 ;;;; ------------------------------------------------------------
 
 (defconst efs-version
-  (concat (substring "$efs release: 1.23 $" 14 -2)
+  (concat (substring "$efs release: 1.24 $" 14 -2)
 	  "/"
 	  (substring "#Revision: 1.91 $" 11 -2)))
 
 (defconst efs-version-host-types '(vms tops-20 ti-twenex ti-explorer)
   "List of host-types which associated a version number to all files.
 This is not the same as associating version numbers to only backup files.")
-;; Note that on these systems, 
+;; Note that on these systems,
 ;;  (file-name-sans-versions EXISTING-FILE) does not exist as a file.
 
 (defconst efs-single-extension-host-types
 ;;;; User customization variables. Please read through these carefully.
 ;;;; ------------------------------------------------------------------
 
-(defgroup efs nil
-  "Transparent ftp access."
-  :group 'files)
-
-(defgroup efs-behavior nil
-  "User-visible aspects of EFS."
-  :prefix "efs-"
-  :group 'efs)
-
-(defgroup efs-auto-save nil
-  "EFS interaction with auto-save."
-  :prefix "efs-"
-  :group 'efs)
-
-(defgroup efs-gateways nil
-  "Using EFS via an ftp gateway."
-  :prefix "efs-"
-  :group 'efs)
-
-(defgroup efs-programs nil
-  "External programs used by EFS."
-  :prefix "efs-"
-  :group 'efs)
-
-(defgroup efs-parameters nil
-  "Behind-the-scenes parameters of EFS."
-  :prefix "efs-"
-  :group 'efs)
-
-(defgroup efs-hooks nil
-  "Hooks for EFS."
-  :prefix "efs-"
-  :group 'efs)
-
-;;;>>>>  If you are not fully connected to the internet,        <<<< 
+;;;>>>>  If you are not fully connected to the internet,        <<<<
 ;;;>>>>  and need to use a gateway (no matter how transparent)  <<<<
 ;;;>>>>  you will need to set some of the following variables.  <<<<
 ;;;>>>>  Read the documentation carefully.                      <<<<
 connection.  Even if the host is accessible by a very transparent FTP gateway,
 it does not qualify as a local host.  The test to determine if machine A is
 local to your machine is if it is possible to ftp from A _back_ to your
-local machine.  Also, open-network-stream must be able to reach the host 
+local machine.  Also, open-network-stream must be able to reach the host
 in question."
   :type 'regexp
   :group 'efs-gateways)
   This indicates that your gateway works by first FTP'ing to it, and
   then giving a  USER command of the form \"USER <username>@<host>\".
   FTP-PROGRAM is the FTP program to use to connect to the gateway; this
-  is most likely \"ftp\".  FTP-PROGRAM-ARGS is a list of arguments to 
+  is most likely \"ftp\".  FTP-PROGRAM-ARGS is a list of arguments to
   pass to it.  You likely want this to be set to the value of
   efs-ftp-program-args <V>.  If the connection to the gateway FTP server
-  is to be on a port different from 21, set efs-gateway-host to 
+  is to be on a port different from 21, set efs-gateway-host to
   \"<host>#<port>\".
 
   '(sidewinder FTP-PROGRAM FTP-PROGRAM-ARGS)
   '(raptor FTP-PROGRAM FTP-PROGRAM-ARGS USER)
   This is for the gateway called raptor by Eagle.  After connecting to the
   the gateway, the command \"user <user>@host USER\" is issued to login
-  as <user> on <host>, where USER is an authentication username for the 
+  as <user> on <host>, where USER is an authentication username for the
   gateway.  After issuing the password for the remote host, efs will
   send the password for USER on efs-gateway-host <V> as an account command.
 
   this remote shell.  Likely values are \"remsh\" or \"rsh\".
   GATEWAY-PROGRAM-ARGS is a list of arguments to pass to GATEWAY-PROGRAM.
   FTP-PROGRAM is the name of the FTP program on the gateway.  A likely setting
-  of this is \"ftp\".  FTP-PROGRAM-ARGS is a list of arguments to pass to 
+  of this is \"ftp\".  FTP-PROGRAM-ARGS is a list of arguments to pass to
   FTP-PROGRAM.  Most likely these should be set to the value of
   efs-ftp-program-args <V>.
 
-  '(interactive GATEWAY-PROGRAM GATEWAY-PROGRAM-ARGS FTP-PROGRAM 
+  '(interactive GATEWAY-PROGRAM GATEWAY-PROGRAM-ARGS FTP-PROGRAM
       FTP-PROGRAM-ARGS)
   This indicates that you need to start an interactive login on your gatway,
   using rlogin, telnet, or something similar.  GATEWAY-PROGRAM is the name
   \"exec ftp\".  FTP-PROGRAM-ARGS is a list of arguments to pass
   to FTP-PROGRAM.  You probably want to set these to the same value as
   efs-ftp-program-args <V>.  If you are using this option, read the
-  documentation at the top of efs-gwp.el, and see 
+  documentation at the top of efs-gwp.el, and see
   efs-gwp-setup-term-command <V>."
   :type '(choice (const nil)
                  (list :tag "Local"
 transfer.
 
 The variable `efs-gateway-hash-mark-size' defines the corresponding value
-for the FTP client on the gateway, if you are using a gateway. 
+for the FTP client on the gateway, if you are using a gateway.
 
 Some client-server combinations do not correctly compute the number of hash
 marks for incoming binary transfers. In this case, a separate variable
 
 (defcustom efs-incoming-binary-hm-size nil
   "*Default hash mark size for incoming binary transfers.
-If this is nil, incoming binary transfers will use `efs-hash-mark-size' as 
+If this is nil, incoming binary transfers will use `efs-hash-mark-size' as
 the default. See the documentation of this variable for more details."
   :type '(choice integer
 		 (const nil))
   :group 'efs-behavior)
 
 (defcustom efs-ftp-activity-function nil
-  "Function called to indicate FTP activity. 
+  "Function called to indicate FTP activity.
 It must have exactly one argument, the number of active FTP sessions as an
 integer."
   :type '(choice function
   :type 'boolean
   :group 'efs-programs)
 
+(defcustom efs-ftp-explicit-empty-file-name
+  (if (eq system-type 'berkeley-unix) ; lukemftp has this problem
+      "\" \""
+    "")
+  "Quoted version of the empty file, if it needs to be specified explicitly.
+Some ftp clients can't handle an empty file, but will accept a filename
+consisting of a single space."
+  :type 'string
+  :group 'efs-programs)
+
 (defcustom efs-nslookup-program
   (and (not (eq system-type 'windows-nt)) "nslookup")
   "*If non-NIL then a string naming the nslookup program."
 (defcustom efs-backup-by-copying nil
   "*Version of `backup by copying' for remote files.
 If non-nil, remote files will be backed up by copying, instead of by renaming.
-Note the copying will be done by moving the file through the local host -- a 
+Note the copying will be done by moving the file through the local host -- a
 very time consuming operation."
   :type 'boolean
   :group 'efs-behavior)
 If non-nil, causes the auto-save file for an efs file to be written in
 the remote directory containing the file, rather than in a local directory.
 For remote files, this overrides a non-nil `auto-save-directory'. Local files
-are unaffected. If you want to use this feature, you probably only want to 
+are unaffected. If you want to use this feature, you probably only want to
 set this true in a few buffers, rather than globally.  You might want to give
 each buffer its own value using `make-variable-buffer-local'. It is usually
 a good idea to auto-save remote files locally, because it is not only faster,
 (defcustom efs-local-apollo-unix
   (eq 0 (string-match "//" (or (getenv "HOME") (getenv "SHELL") "")))
   "*Defines whether the local machine is an apollo running Domain.
-This variable has nothing to do with efs, and should be basic to all 
+This variable has nothing to do with efs, and should be basic to all
 of emacs."
   :type 'boolean
   :group 'efs-parameters)
     "nlist")
    ;; Blind guess
    ("ls"))
-  "*FTP client command for getting a brief listing (NLST) from the FTP server. 
+  "*FTP client command for getting a brief listing (NLST) from the FTP server.
 We try to guess this based on the local system-type, but obviously if you
 are using a gateway, you'll have to set it yourself."
   :type 'string
 Case-insensitive file names are files on hosts whose host type is in
 `efs-case-insensitive-host-types'.
 
-If this is 'up upper case is used, if it is 'down lower case is used. 
-If this has any other value, the case is inherited from the name used 
+If this is 'up upper case is used, if it is 'down lower case is used.
+If this has any other value, the case is inherited from the name used
 to access the file."
   :type '(choice (const nil)
 		 (const up)
 
 (defcustom efs-verify-anonymous-modtime nil
   "*Determines if efs checks modtimes for remote files on anonymous logins.
-If non-nil, efs runs `verify-visited-file-modtime' for remote files on 
+If non-nil, efs runs `verify-visited-file-modtime' for remote files on
 anonymous ftp logins. Since verify-visited-file-modtime slows things down,
 and most people aren't editing files on anonymous ftp logins, this is nil
 by default."
 
 (defcustom efs-load-hook nil
   "Hook to run immediately after loading efs.el.
-You can use it to alter definitions in efs.el, but why would you want 
+You can use it to alter definitions in efs.el, but why would you want
 to do such a thing?"
   :type 'hook
   :group 'efs-hooks)
    (cons "^ls \\|^put \\|^get \\|^append \\|passive"
 	 ;; Some ftp clients try this first by default and do not
 	 ;; filter out the reply.
-	 "^500 .*\\(EPSV\\|EPRT\\).* not understood")))
-  
+	 "^500 .*\\(EPSV\\|EPRT\\).* not understood")
+   ;; Regexp to match failed IPv6 connection attempts
+   (cons "^open "
+	 "^ftp: .*`?[0-9a-zA-Z]+:[0-9a-zA-Z:]+'?: No route to host")))
+
 (defvar efs-cmd-ok-msgs
   ;; RFC959 and RFC2428 compliant
   "^200 \\|^227 \\|^229")
 ;; Regexp to match the server command OK response.
 ;; Because PORT commands return this we usually ignore it. However, it is
 ;; a valid response for TYPE, SITE, and a few other commands (cf. RFC 959).
-;; If we are explicitly sending a PORT, or one of these other commands, 
+;; If we are explicitly sending a PORT, or one of these other commands,
 ;; then we don't want to ignore this response code.  Also use this to match
 ;; the return code for PASV, as some clients burp these things out at odd
 ;; times.
   ;; then does send a second completion code for the command. This does
   ;; *not* conform to RFC959.
   "^100 Warning: type is ")
-;; Regexp to match non-standard response from the FTP server. This can 
+;; Regexp to match non-standard response from the FTP server. This can
 ;; sometimes be the result of an incorrectly set transfer mode. In this case
 ;; we do not rely on the server to tell us when the data transfer is complete,
 ;; but check with the client.
 (defvar efs-idle-msgs
   "^200 [^0-9]+ \\([0-9]+\\)[^0-9]* max \\([0-9]+\\)")
 ;; Regexp to match the output of a SITE IDLE command.
-;; Match 1 should refer to the current idle time, and match 2 the maximum 
+;; Match 1 should refer to the current idle time, and match 2 the maximum
 ;; idle time.
 
 (defvar efs-write-protect-msgs "^532 ") ; RFC959
 	 ;; and they can be padded on the right with spaces.
 	 ;; weiand: changed: month ends potentially with . or , or .,
 	 ;;old	 (month (concat l l "+ *"))
-	 (month (concat l l "+[.]?,? *"))
-	 (date "[ 0-3][0-9]")
+	 (l-or-quote "\\([A-Za-z']\\|[^\0-\177]\\)")
+	 ;; In some locales, month abbreviations are as short as 2 letters,
+	 ;; and they can be followed by ".".
+	 ;; In Breton, a month name can include a quote character.
+	 (month (concat l-or-quote l-or-quote "+\\.?"))
+	 (date "[ 0-3][0-9]\\.?")
 	 (time "[ 012][0-9]:[0-6][0-9]")
 	 (year (concat
 		"\\("
   (concat
    "\\([^ ][-r][-w][^ ][-r][-w][^ ][-r][-w][^ ]\\)[-+]? *\\([0-9]+\\)"
    " +\\([^ ]+\\) "))
-  
+
 ;;;; ---------------------------------------------------------------
 ;;;; efs-dired variables
 ;;;; ---------------------------------------------------------------
 (efs-define-fun efs-relativize-filename (file &optional dir new)
   "Abbreviate the given filename relative to DIR .
 If DIR is nil, use the value of `default-directory' for the currently selected
-window. If the optional parameter NEW is given and the 
+window. If the optional parameter NEW is given and the
 non-directory parts match, only return the directory part of the file."
   (let* ((dir (or dir (save-excursion
 			(set-buffer (window-buffer (selected-window)))
 The function `system-name' is not returning a fully qualified
 domain name. An attempt to obtain a fully qualified domain name
 with `efs-nslookup-program' (currently set to \"%s\") has
-elicited no response from that program. Consider setting 
+elicited no response from that program. Consider setting
 `efs-generate-anonymous-password' to an email address for anonymous
 ftp passwords.
 
 		  sys))))))
 
 (defun efs-passwd-unique-list (alist)
-  ;; Preserving the relative order of ALIST, remove all entries with duplicate 
+  ;; Preserving the relative order of ALIST, remove all entries with duplicate
   ;; cars.
   (let (result)
     (while alist
 			     tertiaries))))))
        efs-host-user-hashtable 'passwd))
     (efs-passwd-unique-list (nconc primaries secondaries tertiaries))))
-    
+
 (defun efs-get-passwd (host user)
   "Given a HOST and USER, return the FTP password, prompting if it was not
 previously set."
   ;; look up password in the hash table first; user might have overriden the
   ;; defaults.
   (cond ((efs-lookup-passwd host user))
-	
+
 	;; see if default user and password set from the .netrc file.
 	((and (stringp efs-default-user)
 	      efs-default-password
 	      (string-equal user efs-default-user))
 	 (copy-sequence efs-default-password))
-	
+
 	;; anonymous ftp password is handled specially since there is an
 	;; unwritten rule about how that is used on the Internet.
 	((and (efs-anonymous-p user)
 	 (if (stringp efs-generate-anonymous-password)
 	     (copy-sequence efs-generate-anonymous-password)
 	   (concat (user-login-name) "@" (efs-system-fqdn))))
-	
+
 	;; see if same user has logged in to other hosts; if so then prompt
 	;; with the password that was used there.
 	(t
 	"efs is unable to identify the following reply code
 from the ftp server " host ":\n\n" line "
 
-Please send a bug report to efs-bugs@hplb.hpl.hp.com.
+Please send a bug report to elisp-code-efs@nongnu.org.
 In your report include a transcript of your\n"
 buff " buffer."))))
   (error "Unable to identify server code."))
 						(match-beginning n)
 						(match-end n)))
 		    -10))))
-	
+
 	((string-match efs-multi-msgs line)
 	 (setq efs-process-result-cont-lines
 	       (concat efs-process-result-cont-lines line "\n")))
-	
+
 	((efs-skip-cmd-msg-p efs-process-cmd line))
 
 	((string-match efs-cmd-ok-msgs line)
 	     (setq efs-process-busy nil
 		   efs-process-result nil
 		   efs-process-result-line line)))
-	
+
 	((string-match efs-bytes-received-msgs line)
 	 (if efs-process-server-confused
 	     (setq efs-process-busy nil
 		   efs-process-result nil
 		   efs-process-result-line line)))
-	
+
 	((string-match efs-server-confused-msgs line)
 	 (setq efs-process-server-confused t))
 
 	 (setq efs-process-busy nil
 	       efs-process-result 'fatal
 	       efs-process-result-line line))
-	
+
 	((string-match efs-failed-msgs line)
 	 (setq efs-process-busy nil
 	       efs-process-result 'failed
 	       efs-process-result-line line))
-	
+
 	((string-match efs-unknown-response-msgs line)
 	 (setq efs-process-busy nil
 	       efs-process-result 'weird
 		(while (string-match efs-process-prompt-regexp line)
 		  (setq line (substring line (match-end 0))))
 		(efs-process-handle-line line proc)))
-	    
+
 	    ;; has the ftp client finished?  if so then do some clean-up
 	    ;; actions.
 	    (if (not efs-process-busy)
 
 			(efs-message "%s...done" efs-process-msg)
 			(setq efs-process-msg nil)))
-		  
+
 		  (if (and efs-process-nowait
 			   (null efs-process-cmd-waiting))
-		      
+
 		      (progn
 			;; Is there a continuation we should be calling?
 			;; If so, we'd better call it, making sure we
 				     efs-process-host
 				     efs-process-user
 				     next))))
-		    
+
 		    (if efs-process-continue
 			(let ((cont efs-process-continue))
 			  (setq efs-process-continue nil)
 			   efs-process-result
 			   efs-process-result-line
 			   efs-process-result-cont-lines))))
-		  
+
 		  ;; Update the mode line
 		  ;; We can't test nowait to see if we changed the
 		  ;; modeline in the first place, because conts
   (let ((proc (efs-get-process-internal host user)))
     (if (and proc (memq (process-status proc) '(run open)))
 	proc
-      
+
       ;; Make sure that the process isn't around in some strange state.
 
       (setq host (downcase host))
       (let ((name (concat "*ftp " user "@" host "*")))
 	(if proc (condition-case nil (delete-process proc) (error nil)))
-	
+
 	;; grab a suitable process.
 	(setq proc (efs-start-process host user name))
-	
+
 	(efs-save-match-data
 	  (efs-save-buffer-excursion
 	    (set-buffer (process-buffer proc))
-	    
+
 	    ;; Run any user-specified hooks.
 	    (run-hooks 'efs-ftp-startup-hook)
-	    
+
 	    ;; login to FTP server.
 	    (efs-login host user proc)
 
 
 		  (if efs-use-passive-mode
 		      (efs-passive-mode host user))
-		  
+
 		  ;; Run any user startup functions
 		  (let ((alist efs-ftp-startup-function-alist)
 			(case-fold-search t))
 			    (funcall (cdr (car alist)) host user)
 			    (setq alist nil))
 			(setq alist (cdr alist)))))
-		  
+
 		  ;; Guess at the host type.
 		  (efs-guess-host-type host user)
-		  
+
 		  ;; Check the idle time.
 		  (efs-check-idle host user)
 
 ;; If PRE-CONT is non-nil, it is called immediately after execution
 ;; of the command starts, but without waiting for it to finish.
 ;; If CONT is non-NIL then it is either a function or a list of function and
-;; some arguments.  The function will be called when the ftp command has 
+;; some arguments.  The function will be called when the ftp command has
 ;; completed.
 ;; If CONT is NIL then this routine will return \( RESULT . LINE \) where
 ;; RESULT is whether the command was successful, and LINE is the line from
 ;; the FTP process that caused the command to complete.
-;; If NOWAIT is nil then we will wait for the command to complete before 
+;; If NOWAIT is nil then we will wait for the command to complete before
 ;; returning. If NOWAIT is 0, then we will wait until the command starts,
 ;; executing before returning. NOWAIT of 1 is like 0, except that the modeline
 ;; will indicate an asynch FTP command.
   (if (memq (process-status proc) '(run open))
       (efs-save-buffer-excursion
 	(set-buffer (process-buffer proc))
-	
+
 	(if efs-process-busy
 	    ;; This function will always wait on a busy process.
 	    ;; Queueing is done by efs-send-cmd.
 	      (save-excursion
 		(apply (car pre-cont) (cdr pre-cont)))))
 	(prog1
-	    (if nowait 
+	    (if nowait
 		nil
 	      ;; hang around for command to complete
 	      ;; Some clients die after the command is sent, if the server
 			    (null efs-process-nowait)
 			    (memq (process-status proc) '(run open)))
 		  (accept-process-output proc)))
-	      
+
 	      ;; cont is called by the process filter
 	      (if cont
 		  ;; Return nil if a cont was called.
 		(list efs-process-result
 		      efs-process-result-line
 		      efs-process-result-cont-lines)))
-	  
+
 	  ;; If the process died, the filter would have never got the chance
 	  ;; to call the cont. Try to jump start things.
-	  
+
 	  (if (and (not (memq (process-status proc) '(run open)))
 		   (string-equal efs-process-result-line "")
 		   cont
 		;; The process may be in some strange state. Get rid of it.
 		(condition-case nil (delete-process proc) (error nil))
 		(efs-call-cont cont 'fatal "" "")))))
-    
+
     (error "FTP process %s has died." (process-name proc))))
 
 (defun efs-quote-percents (string)
   ;; capability. Also, sends umask if nec.
 
   (let ((proc (efs-get-process host user)))
-    
+
     (if (and
 	 (eq nowait t)
 	 (save-excursion
 	   (set-buffer (process-buffer proc))
 	   (or efs-process-busy
 	       efs-process-cmd-waiting)))
-	
+
 	(progn
 	  (efs-add-to-queue
 	   host user
 	   ;; side, store nowait as 1.
 	   (list cmd msg pre-cont cont 1 noretry))
 	  nil)
-      
+
       ;; Send a command.
 
       (let (cmd-string afsc-result afsc-line afsc-cont-lines)
 	      (cmd1 (nth 1 cmd))
 	      (cmd2 (nth 2 cmd))
 	      (cmd3 (nth 3 cmd)))
-	  
+
 	  (cond
-	   
+
 	   ((eq cmd0 'quote)
 	    ;; QUOTEd commands
 	    (cond
-	     
+
 	     ((eq cmd1 'site)
 	      ;; SITE commands
 	      (cond
 					   cmd4))))
 	       (t (error "efs: Don't know how to send %s %s %s %s"
 			 cmd0 cmd1 cmd2 cmd3))))
-	     
+
 	     ((memq cmd1 '(pwd xpwd syst pasv noop))
 	      (setq cmd-string (concat "quote " (symbol-name cmd1))))
-	     
+
 	     ;; PORT command (cmd2 is IP + port address)
 	     ((eq cmd1 'port)
 	      (setq cmd-string (concat "quote port " cmd2)))
 					     (efs-fix-path host-type cmd2))
 		      cmd-string (concat "quote " (symbol-name cmd1) " "
 					 cmd2))))
-	     
+
 	     ((eq cmd1 'stor)
 	      (let ((host-type (efs-host-type host user)))
 		(if (memq host-type efs-unix-host-types)
 		(setq cmd2 (efs-quote-string host-type
 					     (efs-fix-path host-type cmd2))
 		      cmd-string (concat "quote stor " cmd2))))
-	     
+
 	     ((memq cmd1 '(size mdtm rnfr))
 	      (let ((host-type (efs-host-type host user)))
 		(setq cmd2 (efs-quote-string host-type
 
 	     ((memq cmd1 '(pass user))
 	      (setq cmd-string (concat "quote " (symbol-name cmd1) " " cmd2)))
-	     
+
 	     (t
 	      (error "efs: Don't know how to send %s %s %s %s"
 		     cmd0 cmd1 cmd2 cmd3))))
-	   
+
 	   ;; TYPE command
 	   ((eq cmd0 'type)
 	    (setq cmd-string (concat "type " (symbol-name cmd1))))
-     
+
 	   ;; CWD command
 	   ((eq cmd0 'cwd)
 	    (let ((host-type (efs-host-type host user)))
 					 (if (eq cmd0 'nlist)
 					     efs-nlist-cmd
 					   "dir")
-					 ;; KLUDGE ALERT:
-					 ;; some ftp clients
-					 ;; (FreeBSD's, notably)
-					 ;; will not handle a null directory
-					 ;; arg correctly.  This will
-					 ;; hopefully work in all
-					 ;; circumstances.
-					 (if (string-equal cmd1 "")
-					     "\" \""
+					 (cond
+					  ((not (string-equal cmd1 ""))
 					   (efs-quote-string host-type cmd1))
+					  ((eq host-type 'vms) "\[\]")
+					  (t efs-ftp-explicit-empty-file-name))
 					 (efs-adjust-local-path cmd2))))
 	       ((setq cmd-string
 		      (format "%s \"%s%s%s\" %s"
 			      (if (string-equal cmd1 "") "" " ")
 			      (efs-quote-string host-type cmd1 t)
 			      (efs-adjust-local-path cmd2)))))))
-	   
+
 	   ;; First argument is the remote pathname
 	   ((memq cmd0 '(delete mkdir rmdir cd))
 	    (let ((host-type (efs-host-type host user)))
 	      (setq cmd1 (efs-quote-string host-type
 					   (efs-fix-path host-type cmd1))
 		    cmd-string (concat (symbol-name cmd0) " " cmd1))))
-	   
+
 	   ;; GET command
 	   ((eq cmd0 'get)
 	    (let ((host-type (efs-host-type host user)))
 				       cmd1
 				       " "
 				       (efs-adjust-local-path cmd2)))))
-	   
+
 	   ;; PUT command
 	   ((eq cmd0 'put)
 	    (let ((host-type (efs-host-type host user)))
 				       (efs-adjust-local-path cmd1)
 				       " "
 				       cmd2))))
-	   
+
 	   ;; CHMOD command
 	   ((eq cmd0 'chmod)
 	    (let ((host-type (efs-host-type host user)))
 	      (setq cmd2 (efs-quote-string host-type
 					   (efs-fix-path host-type cmd2))
 		    cmd-string (concat "chmod " cmd1 " " cmd2))))
-	   
+
 	   ;; Both arguments are remote pathnames
 	   ((eq cmd0 'rename)
 	    (let ((host-type (efs-host-type host user)))
 		    cmd2 (efs-quote-string host-type
 					   (efs-fix-path host-type cmd2))
 		    cmd-string (concat "rename " cmd1 " " cmd2))))
-	   
+
 	   ;; passive command
 	   ((eq cmd0 'passive)
 	    (setq cmd-string "passive"))
-	
+
 	   (t
 	    (error "efs: Don't know how to send %s %s %s %s"
 		   cmd0 cmd1 cmd2 cmd3))))
-	  
+
 	;; Actually send the resulting command.
 	;; Why do we use this complicated binding of afsc-{result,line},
 	;; rather then use the fact that efs-raw-send-cmd returns?
 	;; Beware, if some of the above FTP commands had to restart
 	;; the process, PROC won't be set to the right process object.
 	(setq proc (efs-get-process host user))
-	
+
 	(efs-raw-send-cmd
 	 proc
 	 cmd-string
 			(setq afsc-result (car retry)
 			      afsc-line (nth 1 retry)
 			      afsc-cont-lines (nth 2 retry)))))
-		 
+
 		 (t (if cont
 			(efs-call-cont cont result line cont-lines)
 		      (or nowait
 				afsc-line line
 				afsc-cont-lines cont-lines))))))
 	 nowait)
-	
+
 	(prog1
 	    (if (or nowait cont)
 		nil
 	      (list afsc-result afsc-line afsc-cont-lines))
-	  
+
 	  ;; Check the queue
 	  (or nowait
 	      efs-nested-cmd
 	     (setq to (efs-nslookup-host to)))
 	(setq cmd (concat "open " to))
 	(if port (setq cmd (concat cmd " " p