lisp/ange-ftp.el

   1 ;;; ange-ftp.el --- transparent FTP support for GNU Emacs
   2
   3 ;;; Copyright (C) 1989,90,91,92,93,94  Free Software Foundation, Inc.
   4 ;;;
   5 ;; Author: Andy Norman (ange@hplb.hpl.hp.com)
   6 ;; Keywords: comm
   7 ;;;
   8 ;;; This program is free software; you can redistribute it and/or modify
   9 ;;; it under the terms of the GNU General Public License as published by
  10 ;;; the Free Software Foundation; either version 2, or (at your option)
  11 ;;; any later version.
  12 ;;;
  13 ;;; This program is distributed in the hope that it will be useful,
  14 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 ;;; GNU General Public License for more details.
  17 ;;;
  18 ;;; A copy of the GNU General Public License can be obtained from this
  19 ;;; program's author (send electronic mail to ange@hplb.hpl.hp.com) or from
  20 ;;; the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA
  21 ;;; 02139, USA.
  22
  23 ;;; Commentary:
  24 ;;;
  25 ;;; This package attempts to make accessing files and directories using FTP
  26 ;;; from within GNU Emacs as simple and transparent as possible.  A subset of
  27 ;;; the common file-handling routines are extended to interact with FTP.
  28
  29 ;;; Usage:
  30 ;;;
  31 ;;; Some of the common GNU Emacs file-handling operations have been made
  32 ;;; FTP-smart.  If one of these routines is given a filename that matches
  33 ;;; '/user@host:name' then it will spawn an FTP process connecting to machine
  34 ;;; 'host' as account 'user' and perform its operation on the file 'name'.
  35 ;;;
  36 ;;; For example: if find-file is given a filename of:
  37 ;;;
  38 ;;;   /ange@anorman:/tmp/notes
  39 ;;;
  40 ;;; then ange-ftp spawns an FTP process, connect to the host 'anorman' as
  41 ;;; user 'ange', get the file '/tmp/notes' and pop up a buffer containing the
  42 ;;; contents of that file as if it were on the local filesystem.  If ange-ftp
  43 ;;; needs a password to connect then it reads one in the echo area.
  44
  45 ;;; Extended filename syntax:
  46 ;;;
  47 ;;; The default extended filename syntax is '/user@host:name', where the
  48 ;;; 'user@' part may be omitted.  This syntax can be customised to a certain
  49 ;;; extent by changing ange-ftp-name-format.  There are limitations.
  50 ;;;
  51 ;;; If the user part is omitted then ange-ftp generates a default user
  52 ;;; instead whose value depends on the variable ange-ftp-default-user.
  53
  54 ;;; Passwords:
  55 ;;;
  56 ;;; A password is required for each host/user pair.  Ange-ftp reads passwords
  57 ;;; as needed.  You can also specify a password with ange-ftp-set-passwd, or
  58 ;;; in a *valid* ~/.netrc file.
  59
  60 ;;; Passwords for user "anonymous":
  61 ;;;
  62 ;;; Passwords for the user "anonymous" (or "ftp") are handled
  63 ;;; specially.  The variable `ange-ftp-generate-anonymous-password'
  64 ;;; controls what happens: if the value of this variable is a string,
  65 ;;; then this is used as the password; if non-nil (the default), then
  66 ;;; a password is created from the name of the user and the hostname
  67 ;;; of the machine on which GNU Emacs is running; if nil then the user
  68 ;;; is prompted for a password as normal.
  69
  70 ;;; "Dumb" UNIX hosts:
  71 ;;;
  72 ;;; The FTP servers on some UNIX machines have problems if the 'ls' command is
  73 ;;; used.
  74 ;;;
  75 ;;; The routine ange-ftp-add-dumb-unix-host can be called to tell ange-ftp to
  76 ;;; limit itself to the DIR command and not 'ls' for a given UNIX host.  Note
  77 ;;; that this change will take effect for the current GNU Emacs session only.
  78 ;;; See below for a discussion of non-UNIX hosts.  If a large number of
  79 ;;; machines with similar hostnames have this problem then it is easier to set
  80 ;;; the value of ange-ftp-dumb-unix-host-regexp in your .emacs file. ange-ftp
  81 ;;; is unable to automatically recognize dumb unix hosts.
  82
  83 ;;; File name completion:
  84 ;;;
  85 ;;; Full file-name completion is supported on UNIX, VMS, CMS, and MTS hosts.
  86 ;;; To do filename completion, ange-ftp needs a listing from the remote host.
  87 ;;; Therefore, for very slow connections, it might not save any time.
  88
  89 ;;; FTP processes:
  90 ;;;
  91 ;;; When ange-ftp starts up an FTP process, it leaves it running for speed
  92 ;;; purposes.  Some FTP servers will close the connection after a period of
  93 ;;; time, but ange-ftp should be able to quietly reconnect the next time that
  94 ;;; the process is needed.
  95 ;;;
  96 ;;; Killing the "*ftp user@host*" buffer also kills the ftp process.
  97 ;;; This should not cause ange-ftp any grief.
  98
  99 ;;; Binary file transfers:
 100 ;;;
 101 ;;; By default ange-ftp transfers files in ASCII mode.  If a file being
 102 ;;; transferred matches the value of ange-ftp-binary-file-name-regexp then
 103 ;;; binary mode is used for that transfer.
 104
 105 ;;; Account passwords:
 106 ;;;
 107 ;;; Some FTP servers require an additional password which is sent by the
 108 ;;; ACCOUNT command.  ange-ftp partially supports this by allowing the user to
 109 ;;; specify an account password by either calling ange-ftp-set-account, or by
 110 ;;; specifying an account token in the .netrc file.  If the account password
 111 ;;; is set by either of these methods then ange-ftp will issue an ACCOUNT
 112 ;;; command upon starting the FTP process.
 113
 114 ;;; Preloading:
 115 ;;;
 116 ;;; ange-ftp can be preloaded, but must be put in the site-init.el file and
 117 ;;; not the site-load.el file in order for the documentation strings for the
 118 ;;; functions being overloaded to be available.
 119
 120 ;;; Status reports:
 121 ;;;
 122 ;;; Most ange-ftp commands that talk to the FTP process output a status
 123 ;;; message on what they are doing.  In addition, ange-ftp can take advantage
 124 ;;; of the FTP client's HASH command to display the status of transferring
 125 ;;; files and listing directories.  See the documentation for the variables
 126 ;;; ange-ftp-{ascii,binary}-hash-mark-size, ange-ftp-send-hash and
 127 ;;; ange-ftp-process-verbose for more details.
 128
 129 ;;; Gateways:
 130 ;;;
 131 ;;; Sometimes it is necessary for the FTP process to be run on a different
 132 ;;; machine than the machine running GNU Emacs.  This can happen when the
 133 ;;; local machine has restrictions on what hosts it can access.
 134 ;;;
 135 ;;; ange-ftp has support for running the ftp process on a different (gateway)
 136 ;;; machine.  The way it works is as follows:
 137 ;;;
 138 ;;; 1) Set the variable 'ange-ftp-gateway-host' to the name of a machine
 139 ;;;    that doesn't have the access restrictions.
 140 ;;;
 141 ;;; 2) Set the variable 'ange-ftp-local-host-regexp' to a regular expression
 142 ;;;    that matches hosts that can be contacted from running a local ftp
 143 ;;;    process, but fails to match hosts that can't be accessed locally.  For
 144 ;;;    example:
 145 ;;;
 146 ;;;    "\\.hp\\.com$\\|^[^.]*$"
 147 ;;;
 148 ;;;    will match all hosts that are in the .hp.com domain, or don't have an
 149 ;;;    explicit domain in their name, but will fail to match hosts with
 150 ;;;    explicit domains or that are specified by their ip address.
 151 ;;;
 152 ;;; 3) Using NFS and symlinks, make sure that there is a shared directory with
 153 ;;;    the *same* name between the local machine and the gateway machine.
 154 ;;;    This directory is necessary for temporary files created by ange-ftp.
 155 ;;;
 156 ;;; 4) Set the variable 'ange-ftp-gateway-tmp-name-template' to the name of
 157 ;;;    this directory plus an identifying filename prefix.  For example:
 158 ;;;
 159 ;;;    "/nfs/hplose/ange/ange-ftp"
 160 ;;;
 161 ;;;    where /nfs/hplose/ange is a directory that is shared between the
 162 ;;;    gateway machine and the local machine.
 163 ;;;
 164 ;;; The simplest way of getting a ftp process running on the gateway machine
 165 ;;; is if you can spawn a remote shell using either 'rsh' or 'remsh'.  If you
 166 ;;; can't do this for some reason such as security then points 7 onwards will
 167 ;;; discuss an alternative approach.
 168 ;;;
 169 ;;; 5) Set the variable ange-ftp-gateway-program to the name of the remote
 170 ;;;    shell process such as 'remsh' or 'rsh' if the default isn't correct.
 171 ;;;
 172 ;;; 6) Set the variable ange-ftp-gateway-program-interactive to nil if it
 173 ;;;    isn't already.  This tells ange-ftp that you are using a remote shell
 174 ;;;    rather than logging in using telnet or rlogin.
 175 ;;;
 176 ;;; That should be all you need to allow ange-ftp to spawn a ftp process on
 177 ;;; the gateway machine.  If you have to use telnet or rlogin to get to the
 178 ;;; gateway machine then follow the instructions below.
 179 ;;;
 180 ;;; 7) Set the variable ange-ftp-gateway-program to the name of the program
 181 ;;;    that lets you log onto the gateway machine.  This may be something like
 182 ;;;    telnet or rlogin.
 183 ;;;
 184 ;;; 8) Set the variable ange-ftp-gateway-prompt-pattern to a regular
 185 ;;;    expression that matches the prompt you get when you login to the
 186 ;;;    gateway machine.  Be very specific here; this regexp must not match
 187 ;;;    *anything* in your login banner except this prompt.
 188 ;;;    shell-prompt-pattern is far too general as it appears to match some
 189 ;;;    login banners from Sun machines.  For example:
 190 ;;;
 191 ;;;    "^$*$ *"
 192 ;;;
 193 ;;; 9) Set the variable ange-ftp-gateway-program-interactive to 't' to let
 194 ;;;    ange-ftp know that it has to "hand-hold" the login to the gateway
 195 ;;;    machine.
 196 ;;;
 197 ;;; 10) Set the variable ange-ftp-gateway-setup-term-command to a UNIX command
 198 ;;;     that will put the pty connected to the gateway machine into a
 199 ;;;     no-echoing mode, and will strip off carriage-returns from output from
 200 ;;;     the gateway machine.  For example:
 201 ;;;
 202 ;;;     "stty -onlcr -echo"
 203 ;;;
 204 ;;;     will work on HP-UX machines, whereas:
 205 ;;;
 206 ;;;     "stty -echo nl"
 207 ;;;
 208 ;;;     appears to work for some Sun machines.
 209 ;;;
 210 ;;; That's all there is to it.
 211
 212 ;;; Smart gateways:
 213 ;;;
 214 ;;; If you have a "smart" ftp program that allows you to issue commands like
 215 ;;; "USER foo@bar" which do nice proxy things, then look at the variables
 216 ;;; ange-ftp-smart-gateway and ange-ftp-smart-gateway-port.
 217
 218 ;;; Tips for using ange-ftp:
 219 ;;;
 220 ;;; 1. For dired to work on a host which marks symlinks with a trailing @ in
 221 ;;;    an ls -alF listing, you need to (setq dired-ls-F-marks-symlinks t).
 222 ;;;    Most UNIX systems do not do this, but ULTRIX does. If you think that
 223 ;;;    there is a chance you might connect to an ULTRIX machine (such as
 224 ;;;    prep.ai.mit.edu), then set this variable accordingly.  This will have
 225 ;;;    the side effect that dired will have problems with symlinks whose names
 226 ;;;    end in an @.  If you get yourself into this situation then editing
 227 ;;;    dired's ls-switches to remove "F", will temporarily fix things.
 228 ;;;
 229 ;;; 2. If you know that you are connecting to a certain non-UNIX machine
 230 ;;;    frequently, and ange-ftp seems to be unable to guess its host-type,
 231 ;;;    then setting the appropriate host-type regexp
 232 ;;;    (ange-ftp-vms-host-regexp, ange-ftp-mts-host-regexp, or
 233 ;;;    ange-ftp-cms-host-regexp) accordingly should help. Also, please report
 234 ;;;    ange-ftp's inability to recognize the host-type as a bug.
 235 ;;;
 236 ;;; 3. For slow connections, you might get "listing unreadable" error
 237 ;;;    messages, or get an empty buffer for a file that you know has something
 238 ;;;    in it. The solution is to increase the value of ange-ftp-retry-time.
 239 ;;;    Its default value is 5 which is plenty for reasonable connections.
 240 ;;;    However, for some transatlantic connections I set this to 20.
 241 ;;;
 242 ;;; 4. Beware of compressing files on non-UNIX hosts. Ange-ftp will do it by
 243 ;;;    copying the file to the local machine, compressing it there, and then
 244 ;;;    sending it back. Binary file transfers between machines of different
 245 ;;;    architectures can be a risky business. Test things out first on some
 246 ;;;    test files. See "Bugs" below. Also, note that ange-ftp copies files by
 247 ;;;    moving them through the local machine. Again, be careful when doing
 248 ;;;    this with binary files on non-Unix machines.
 249 ;;;
 250 ;;; 5. Beware that dired over ftp will use your setting of dired-no-confirm
 251 ;;;    (list of dired commands for which confirmation is not asked).  You
 252 ;;;    might want to reconsider your setting of this variable, because you
 253 ;;;    might want confirmation for more commands on remote direds than on
 254 ;;;    local direds. For example, I strongly recommend that you not include
 255 ;;;    compress and uncompress in this list. If there is enough demand it
 256 ;;;    might be a good idea to have an alist ange-ftp-dired-no-confirm of
 257 ;;;    pairs ( TYPE . LIST ), where TYPE is an operating system type and LIST
 258 ;;;    is a list of commands for which confirmation would be suppressed.  Then
 259 ;;;    remote dired listings would take their (buffer-local) value of
 260 ;;;    dired-no-confirm from this alist. Who votes for this?
 261
 262 ;;; ---------------------------------------------------------------------
 263 ;;; Non-UNIX support:
 264 ;;; ---------------------------------------------------------------------
 265
 266 ;;; VMS support:
 267 ;;;
 268 ;;; Ange-ftp has full support for VMS hosts.  It
 269 ;;; should be able to automatically recognize any VMS machine. However, if it
 270 ;;; fails to do this, you can use the command ange-ftp-add-vms-host.  As well,
 271 ;;; you can set the variable ange-ftp-vms-host-regexp in your .emacs file. We
 272 ;;; would be grateful if you would report any failures to automatically
 273 ;;; recognize a VMS host as a bug.
 274 ;;;
 275 ;;; Filename Syntax:
 276 ;;;
 277 ;;; For ease of *implementation*, the user enters the VMS filename syntax in a
 278 ;;; UNIX-y way.  For example:
 279 ;;;  PUB$:[ANONYMOUS.SDSCPUB.NEXT]README.TXT;1
 280 ;;; would be entered as:
 281 ;;;  /PUB$$:/ANONYMOUS/SDSCPUB/NEXT/README.TXT;1
 282 ;;; i.e. to log in as anonymous on ymir.claremont.edu and grab the file:
 283 ;;;  [.CSV.POLICY]RULES.MEM
 284 ;;; you would type:
 285 ;;;  C-x C-f /anonymous@ymir.claremont.edu:CSV/POLICY/RULES.MEM
 286 ;;;
 287 ;;; A legal VMS filename is of the form: FILE.TYPE;##
 288 ;;; where FILE can be up to 39 characters
 289 ;;;       TYPE can be up to 39 characters
 290 ;;;       ## is a version number (an integer between 1 and 32,767)
 291 ;;; Valid characters in FILE and TYPE are A-Z 0-9 _ - $
 292 ;;; $ cannot begin a filename, and - cannot be used as the first or last
 293 ;;; character.
 294 ;;;
 295 ;;; Tips:
 296 ;;; 1. Although VMS is not case sensitive, EMACS running under UNIX is.
 297 ;;;    Therefore, to access a VMS file, you must enter the filename with upper
 298 ;;;    case letters.
 299 ;;; 2. To access the latest version of file under VMS, you use the filename
 300 ;;;    without the ";" and version number. You should always edit the latest
 301 ;;;    version of a file. If you want to edit an earlier version, copy it to a
 302 ;;;    new file first. This has nothing to do with ange-ftp, but is simply
 303 ;;;    good VMS operating practice. Therefore, to edit FILE.TXT;3 (say 3 is
 304 ;;;    latest version), do C-x C-f /ymir.claremont.edu:FILE.TXT. If you
 305 ;;;    inadvertently do C-x C-f /ymir.claremont.edu:FILE.TXT;3, you will find
 306 ;;;    that VMS will not allow you to save the file because it will refuse to
 307 ;;;    overwrite FILE.TXT;3, but instead will want to create FILE.TXT;4, and
 308 ;;;    attach the buffer to this file. To get out of this situation, M-x
 309 ;;;    write-file /ymir.claremont.edu:FILE.TXT will attach the buffer to
 310 ;;;    latest version of the file. For this reason, in dired "f"
 311 ;;;    (dired-find-file), always loads the file sans version, whereas "v",
 312 ;;;    (dired-view-file), always loads the explicit version number. The
 313 ;;;    reasoning being that it reasonable to view old versions of a file, but
 314 ;;;    not to edit them.
 315 ;;; 3. EMACS has a feature in which it does environment variable substitution
 316 ;;;    in filenames. Therefore, to enter a $ in a filename, you must quote it
 317 ;;;    by typing $$.
 318
 319 ;;; MTS support:
 320 ;;;
 321 ;;; Ange-ftp has full support for hosts running
 322 ;;; the Michigan terminal system.  It should be able to automatically
 323 ;;; recognize any MTS machine. However, if it fails to do this, you can use
 324 ;;; the command ange-ftp-add-mts-host.  As well, you can set the variable
 325 ;;; ange-ftp-mts-host-regexp in your .emacs file. We would be grateful if you
 326 ;;; would report any failures to automatically recognize a MTS host as a bug.
 327 ;;;
 328 ;;; Filename syntax:
 329 ;;;
 330 ;;; MTS filenames are entered in a UNIX-y way. For example, if your account
 331 ;;; was YYYY, the file FILE in the account XXXX: on mtsg.ubc.ca would be
 332 ;;; entered as
 333 ;;;   /YYYY@mtsg.ubc.ca:/XXXX:/FILE
 334 ;;; In other words, MTS accounts are treated as UNIX directories. Of course,
 335 ;;; to access a file in another account, you must have access permission for
 336 ;;; it.  If FILE were in your own account, then you could enter it in a
 337 ;;; relative name fashion as
 338 ;;;   /YYYY@mtsg.ubc.ca:FILE
 339 ;;; MTS filenames can be up to 12 characters. Like UNIX, the structure of the
 340 ;;; filename does not contain a TYPE (i.e. it can have as many "."'s as you
 341 ;;; like.) MTS filenames are always in upper case, and hence be sure to enter
 342 ;;; them as such! MTS is not case sensitive, but an EMACS running under UNIX
 343 ;;; is.
 344
 345 ;;; CMS support:
 346 ;;;
 347 ;;; Ange-ftp has full support for hosts running
 348 ;;; CMS.  It should be able to automatically recognize any CMS machine.
 349 ;;; However, if it fails to do this, you can use the command
 350 ;;; ange-ftp-add-cms-host.  As well, you can set the variable
 351 ;;; ange-ftp-cms-host-regexp in your .emacs file. We would be grateful if you
 352 ;;; would report any failures to automatically recognize a CMS host as a bug.
 353 ;;;
 354 ;;; Filename syntax:
 355 ;;;
 356 ;;; CMS filenames are entered in a UNIX-y way. In otherwords, minidisks are
 357 ;;; treated as UNIX directories. For example to access the file READ.ME in
 358 ;;; minidisk *.311 on cuvmb.cc.columbia.edu, you would enter
 359 ;;;   /anonymous@cuvmb.cc.columbia.edu:/*.311/READ.ME
 360 ;;; If *.301 is the default minidisk for this account, you could access
 361 ;;; FOO.BAR on this minidisk as
 362 ;;;   /anonymous@cuvmb.cc.columbia.edu:FOO.BAR
 363 ;;; CMS filenames are of the form FILE.TYPE, where both FILE and TYPE can be
 364 ;;; up to 8 characters. Again, beware that CMS filenames are always upper
 365 ;;; case, and hence must be entered as such.
 366 ;;;
 367 ;;; Tips:
 368 ;;; 1. CMS machines, with the exception of anonymous accounts, nearly always
 369 ;;;    need an account password. To have ange-ftp send an account password,
 370 ;;;    you can either include it in your .netrc file, or use
 371 ;;;    ange-ftp-set-account.
 372 ;;; 2. Ange-ftp cannot send "write passwords" for a minidisk. Hopefully, we
 373 ;;;    can fix this.
 374 ;;;
 375 ;;; ------------------------------------------------------------------
 376 ;;; Bugs:
 377 ;;; ------------------------------------------------------------------
 378 ;;;
 379 ;;; 1. Umask problems:
 380 ;;;    Be warned that files created by using ange-ftp will take account of the
 381 ;;;    umask of the ftp daemon process rather than the umask of the creating
 382 ;;;    user.  This is particularly important when logging in as the root user.
 383 ;;;    The way that I tighten up the ftp daemon's umask under HP-UX is to make
 384 ;;;    sure that the umask is changed to 027 before I spawn /etc/inetd.  I
 385 ;;;    suspect that there is something similar on other systems.
 386 ;;;
 387 ;;; 2. Some combinations of FTP clients and servers break and get out of sync
 388 ;;;    when asked to list a non-existent directory.  Some of the ai.mit.edu
 389 ;;;    machines cause this problem for some FTP clients. Using
 390 ;;;    ange-ftp-kill-ftp-process can restart the ftp process, which
 391 ;;;    should get things back in synch.
 392 ;;;
 393 ;;; 3. Ange-ftp does not check to make sure that when creating a new file,
 394 ;;;    you provide a valid filename for the remote operating system.
 395 ;;;    If you do not, then the remote FTP server will most likely
 396 ;;;    translate your filename in some way. This may cause ange-ftp to
 397 ;;;    get confused about what exactly is the name of the file. The
 398 ;;;    most common causes of this are using lower case filenames on systems
 399 ;;;    which support only upper case, and using filenames which are too
 400 ;;;    long.
 401 ;;;
 402 ;;; 4. Null (blank) passwords confuse both ange-ftp and some FTP daemons.
 403 ;;;
 404 ;;; 5. Ange-ftp likes to use pty's to talk to its FTP processes.  If GNU Emacs
 405 ;;;    for some reason creates a FTP process that only talks via pipes then
 406 ;;;    ange-ftp won't be getting the information it requires at the time that
 407 ;;;    it wants it since pipes flush at different times to pty's.  One
 408 ;;;    disgusting way around this problem is to talk to the FTP process via
 409 ;;;    rlogin which does the 'right' things with pty's.
 410 ;;;
 411 ;;; 6. For CMS support, we send too many cd's. Since cd's are cheap, I haven't
 412 ;;;    worried about this too much. Eventually, we should have some caching
 413 ;;;    of the current minidisk.
 414 ;;;
 415 ;;; 7. Some CMS machines do not assign a default minidisk when you ftp them as
 416 ;;;    anonymous. It is then necessary to guess a valid minidisk name, and cd
 417 ;;;    to it. This is (understandably) beyond ange-ftp.
 418 ;;;
 419 ;;; 8. Remote to remote copying of files on non-Unix machines can be risky.
 420 ;;;    Depending on the variable ange-ftp-binary-file-name-regexp, ange-ftp
 421 ;;;    will use binary mode for the copy. Between systems of different
 422 ;;;    architecture, this still may not be enough to guarantee the integrity
 423 ;;;    of binary files. Binary file transfers from VMS machines are
 424 ;;;    particularly problematical. Should ange-ftp-binary-file-name-regexp be
 425 ;;;    an alist of OS type, regexp pairs?
 426 ;;;
 427 ;;; 9. The code to do compression of files over ftp is not as careful as it
 428 ;;;    should be. It deletes the old remote version of the file, before
 429 ;;;    actually checking if the local to remote transfer of the compressed
 430 ;;;    file succeeds. Of course to delete the original version of the file
 431 ;;;    after transferring the compressed version back is also dangerous,
 432 ;;;    because some OS's have severe restrictions on the length of filenames,
 433 ;;;    and when the compressed version is copied back the "-Z" or ".Z" may be
 434 ;;;    truncated. Then, ange-ftp would delete the only remaining version of
 435 ;;;    the file.  Maybe ange-ftp should make backups when it compresses files
 436 ;;;    (of course, the backup "~" could also be truncated off, sigh...).
 437 ;;;    Suggestions?
 438 ;;;
 439
 440 ;;; 10. If a dir listing is attempted for an empty directory on (at least
 441 ;;;     some) VMS hosts, an ftp error is given. This is really an ftp bug, and
 442 ;;;     I don't know how to get ange-ftp work to around it.
 443 ;;;
 444 ;;; 11. Bombs on filenames that start with a space. Deals well with filenames
 445 ;;;     containing spaces, but beware that the remote ftpd may not like them
 446 ;;;     much.
 447 ;;;
 448 ;;; 12. The dired support for non-Unix-like systems does not currently work.
 449 ;;;     It needs to be reimplemented by modifying the parse-...-listing
 450 ;;;     functions to convert the directory listing to ls -l format.
 451 ;;;
 452 ;;; 13. The famous @ bug. As mentioned above in TIPS, ULTRIX marks symlinks
 453 ;;;     with a trailing @ in a ls -alF listing. In order to account for this
 454 ;;;     ange-ftp looks to chop trailing @'s off of symlink names when it is
 455 ;;;     parsing a listing with the F switch. This will cause ange-ftp to
 456 ;;;     incorrectly get the name of a symlink on a non-ULTRIX host if its name
 457 ;;;     ends in an @. ange-ftp will correct itself if you take F out of the
 458 ;;;     dired ls switches (C-u s will allow you to edit the switches). The
 459 ;;;     dired buffer will be automatically reverted, which will allow ange-ftp
 460 ;;;     to fix its files hashtable.  A cookie to anyone who can think of a
 461 ;;;     fast, sure-fire way to recognize ULTRIX over ftp.
 462
 463 ;;; If you find any bugs or problems with this package, PLEASE either e-mail
 464 ;;; the above author, or send a message to the ange-ftp-lovers mailing list
 465 ;;; below.  Ideas and constructive comments are especially welcome.
 466
 467 ;;; ange-ftp-lovers:
 468 ;;;
 469 ;;; ange-ftp has its own mailing list modestly called ange-ftp-lovers.  All
 470 ;;; users of ange-ftp are welcome to subscribe (see below) and to discuss
 471 ;;; aspects of ange-ftp.  New versions of ange-ftp are posted periodically to
 472 ;;; the mailing list.
 473 ;;;
 474 ;;; To [un]subscribe to ange-ftp-lovers, or to report mailer problems with the
 475 ;;; list, please mail one of the following addresses:
 476 ;;;
 477 ;;;     ange-ftp-lovers-request@anorman.hpl.hp.com
 478 ;;; or
 479 ;;;     ange-ftp-lovers-request%anorman.hpl.hp.com@hplb.hpl.hp.com
 480 ;;;
 481 ;;; Please don't forget the -request part.
 482 ;;;
 483 ;;; For mail to be posted directly to ange-ftp-lovers, send to one of the
 484 ;;; following addresses:
 485 ;;;
 486 ;;;     ange-ftp-lovers@anorman.hpl.hp.com
 487 ;;; or
 488 ;;;     ange-ftp-lovers%anorman.hpl.hp.com@hplb.hpl.hp.com
 489 ;;;
 490 ;;; Alternatively, there is a mailing list that only gets announcements of new
 491 ;;; ange-ftp releases.  This is called ange-ftp-lovers-announce, and can be
 492 ;;; subscribed to by e-mailing to the -request address as above.  Please make
 493 ;;; it clear in the request which mailing list you wish to join.
 494
 495 ;;; The latest version of ange-ftp can usually be obtained via anonymous ftp
 496 ;;; from:
 497 ;;;     alpha.gnu.ai.mit.edu:ange-ftp/ange-ftp.tar.Z
 498 ;;; or:
 499 ;;;     ugle.unit.no:/pub/gnu/emacs-lisp/ange-ftp.tar.Z
 500 ;;; or:
 501 ;;;   archive.cis.ohio-state.edu:pub/gnu/emacs/elisp-archive/packages/ange-ftp.tar.Z
 502
 503 ;;; The archives for ange-ftp-lovers can be found via anonymous ftp under:
 504 ;;;
 505 ;;;     ftp.reed.edu:pub/mailing-lists/ange-ftp/
 506 \f
 507 ;;; -----------------------------------------------------------
 508 ;;; Technical information on this package:
 509 ;;; -----------------------------------------------------------
 510
 511 ;;; ange-ftp works by putting a handler on file-name-handler-alist
 512 ;;; which is called by many primitives, and a few non-primitives,
 513 ;;; whenever they see a file name of the appropriate sort.
 514
 515 ;;; Checklist for adding non-UNIX support for TYPE
 516 ;;;
 517 ;;; The following functions may need TYPE versions:
 518 ;;; (not all functions will be needed for every OS)
 519 ;;;
 520 ;;; ange-ftp-fix-name-for-TYPE
 521 ;;; ange-ftp-fix-dir-name-for-TYPE
 522 ;;; ange-ftp-TYPE-host
 523 ;;; ange-ftp-TYPE-add-host
 524 ;;; ange-ftp-parse-TYPE-listing
 525 ;;; ange-ftp-TYPE-delete-file-entry
 526 ;;; ange-ftp-TYPE-add-file-entry
 527 ;;; ange-ftp-TYPE-file-name-as-directory
 528 ;;; ange-ftp-TYPE-make-compressed-filename
 529 ;;; ange-ftp-TYPE-file-name-sans-versions
 530 ;;;
 531 ;;; Variables:
 532 ;;;
 533 ;;; ange-ftp-TYPE-host-regexp
 534 ;;; May need to add TYPE to ange-ftp-dumb-host-types
 535 ;;;
 536 ;;; Check the following functions for OS dependent coding:
 537 ;;;
 538 ;;; ange-ftp-host-type
 539 ;;; ange-ftp-guess-host-type
 540 ;;; ange-ftp-allow-child-lookup
 541
 542 ;;; Host type conventions:
 543 ;;;
 544 ;;; The function ange-ftp-host-type and the variable ange-ftp-dired-host-type
 545 ;;; (mostly) follow the following conventions for remote host types.  At
 546 ;;; least, I think that future code should try to follow these conventions,
 547 ;;; and the current code should eventually be made compliant.
 548 ;;;
 549 ;;; nil = local host type, whatever that is (probably unix).
 550 ;;;       Think nil as in "not a remote host". This value is used by
 551 ;;;       ange-ftp-dired-host-type for local buffers.
 552 ;;;
 553 ;;; t = a remote host of unknown type. Think t is in true, it's remote.
 554 ;;;     Currently, 'unix is used as the default remote host type.
 555 ;;;     Maybe we should use t.
 556 ;;;
 557 ;;; 'type = a remote host of TYPE type.
 558 ;;;
 559 ;;; 'type:list = a remote host of TYPE type, using a specialized ftp listing
 560 ;;;              program called list. This is currently only used for Unix
 561 ;;;              dl (descriptive listings), when ange-ftp-dired-host-type
 562 ;;;              is set to 'unix:dl.
 563
 564 ;;; Bug report codes:
 565 ;;;
 566 ;;; Because of their naive faith in this code, there are certain situations
 567 ;;; which the writers of this program believe could never happen. However,
 568 ;;; being realists they have put calls to `error' in the program at these
 569 ;;; points. These errors provide a code, which is an integer, greater than 1.
 570 ;;; To aid debugging.  the error codes, and the functions in which they reside
 571 ;;; are listed below.
 572 ;;;
 573 ;;; 1: See ange-ftp-ls
 574 ;;;
 575 \f
 576 ;;; -----------------------------------------------------------
 577 ;;; Hall of fame:
 578 ;;; -----------------------------------------------------------
 579 ;;;
 580 ;;; Thanks to Roland McGrath for improving the filename syntax handling,
 581 ;;; for suggesting many enhancements and for numerous cleanups to the code.
 582 ;;;
 583 ;;; Thanks to Jamie Zawinski for bugfixes and for ideas such as gateways.
 584 ;;;
 585 ;;; Thanks to Ken Laprade for improved .netrc parsing, password reading, and
 586 ;;; dired / shell auto-loading.
 587 ;;;
 588 ;;; Thanks to Sebastian Kremer for dired support and for many ideas and
 589 ;;; bugfixes.
 590 ;;;
 591 ;;; Thanks to Joe Wells for bugfixes, the original non-UNIX system support,
 592 ;;; VOS support, and hostname completion.
 593 ;;;
 594 ;;; Thanks to Nakagawa Takayuki for many good ideas, filename-completion, help
 595 ;;; with file-name expansion, efficiency worries, stylistic concerns and many
 596 ;;; bugfixes.
 597 ;;;
 598 ;;; Thanks to Sandy Rutherford who re-wrote most of ange-ftp to support VMS,
 599 ;;; MTS, CMS and UNIX-dls.  Sandy also added dired-support for non-UNIX OS and
 600 ;;; auto-recognition of the host type.
 601 ;;;
 602 ;;; Thanks to Dave Smith who wrote the info file for ange-ftp.
 603 ;;;
 604 ;;; Finally, thanks to Keith Waclena, Mark D. Baushke, Terence Kelleher, Ping
 605 ;;; Zhou, Edward Vielmetti, Jack Repenning, Mike Balenger, Todd Kaufmann,
 606 ;;; Kjetil Svarstad, Tom Wurgler, Linus Tolke, Niko Makila, Carl Edman, Bill
 607 ;;; Trost, Dave Brennan, Dan Jacobson, Andy Scott, Steve Anderson, Sanjay
 608 ;;; Mathur, the folks on the ange-ftp-lovers mailing list and many others
 609 ;;; whose names I've forgotten who have helped to debug and fix problems with
 610 ;;; ange-ftp.el.
 611 \f
 612
 613 ;;; Code:
 614 (require 'comint)
 615
 616 ;;;; ------------------------------------------------------------
 617 ;;;; User customization variables.
 618 ;;;; ------------------------------------------------------------
 619
 620 (defvar ange-ftp-name-format
 621   '("^/\\(\\([^@/:]*\\)@\\)?\\([^@/:]*\\):\\(.*\\)" . (3 2 4))
 622   "*Format of a fully expanded remote file name.
 623 This is a list of the form \(REGEXP HOST USER NAME\),
 624 where REGEXP is a regular expression matching
 625 the full remote name, and HOST, USER, and NAME are the numbers of
 626 parenthesized expressions in REGEXP for the components (in that order).")
 627
 628 ;; ange-ftp-multi-skip-msgs should only match ###-, where ### is one of
 629 ;; the number codes corresponding to ange-ftp-good-msgs or ange-ftp-fatal-msgs.
 630 ;; Otherwise, ange-ftp will go into multi-skip mode, and never come out.
 631
 632 (defvar ange-ftp-multi-msgs
 633   "^220-\\|^230-\\|^226\\|^25.-\\|^221-\\|^200-\\|^331-\\|^4[25]1-\\|^530-"
 634   "*Regular expression matching the start of a multiline ftp reply.")
 635
 636 (defvar ange-ftp-good-msgs
 637   "^220 \\|^230 \\|^226 \\|^25. \\|^221 \\|^200 \\|^[Hh]ash mark"
 638   "*Regular expression matching ftp \"success\" messages.")
 639
 640 ;; CMS and the odd VMS machine say 200 Port rather than 200 PORT.
 641 ;; Also CMS machines use a multiline 550- reply to say that you
 642 ;; don't have write permission. ange-ftp gets into multi-line skip
 643 ;; mode and hangs. Have it ignore 550- instead. It will then barf
 644 ;; when it gets the 550 line, as it should.
 645
 646 (defvar ange-ftp-skip-msgs
 647   (concat "^200 \\(PORT\\|Port\\) \\|^331 \\|^150 \\|^350 \\|^[0-9]+ bytes \\|"
 648           "^Connected \\|^$\\|^Remote system\\|^Using\\|^ \\|Password:\\|"
 649           "^local:\\|^Trying\\|^125 \\|^550-\\|^221 .*oodbye")
 650   "*Regular expression matching ftp messages that can be ignored.")
 651
 652 (defvar ange-ftp-fatal-msgs
 653   (concat "^ftp: \\|^Not connected\\|^530 \\|^4[25]1 \\|rcmd: \\|"
 654           "^No control connection\\|unknown host\\|^lost connection")
 655   "*Regular expression matching ftp messages that indicate serious errors.
 656 These mean that the FTP process should (or already has) been killed.")
 657
 658 (defvar ange-ftp-gateway-fatal-msgs
 659   "No route to host\\|Connection closed\\|No such host\\|Login incorrect"
 660   "*Regular expression matching login failure messages from rlogin/telnet.")
 661
 662 (defvar ange-ftp-xfer-size-msgs
 663   "^150 .* connection for .* (\\([0-9]+\\) bytes)"
 664   "*Regular expression used to determine the number of bytes in a FTP transfer.")
 665
 666 (defvar ange-ftp-tmp-name-template "/tmp/ange-ftp"
 667   "*Template used to create temporary files.")
 668
 669 (defvar ange-ftp-gateway-tmp-name-template "/tmp/ange-ftp"
 670   "*Template used to create temporary files when ftp-ing through a gateway.
 671 Files starting with this prefix need to be accessible from BOTH the local
 672 machine and the gateway machine, and need to have the SAME name on both
 673 machines, that is, /tmp is probably NOT what you want, since that is rarely
 674 cross-mounted.")
 675
 676 (defvar ange-ftp-netrc-filename "~/.netrc"
 677   "*File in .netrc format to search for passwords.")
 678
 679 (defvar ange-ftp-disable-netrc-security-check nil
 680   "*If non-nil avoid checking permissions on the .netrc file.")
 681
 682 (defvar ange-ftp-default-user nil
 683   "*User name to use when none is specied in a file name.
 684 If nil, then the name under which the user is logged in is used.
 685 If non-nil but not a string, the user is prompted for the name.")
 686
 687 (defvar ange-ftp-default-password nil
 688   "*Password to use when the user is the same as ange-ftp-default-user.")
 689
 690 (defvar ange-ftp-default-account nil
 691   "*Account password to use when the user is the same as ange-ftp-default-user.")
 692
 693 (defvar ange-ftp-generate-anonymous-password t
 694   "*If t, use a password of user@host when logging in as the anonymous user.
 695 If a string then use that as the password.
 696 If nil then prompt the user for a password.")
 697
 698 (defvar ange-ftp-dumb-unix-host-regexp nil
 699   "*If non-nil, regexp matching hosts on which `dir' command lists directory.")
 700
 701 (defvar ange-ftp-binary-file-name-regexp
 702   (concat "\\.[zZ]$\\|\\.lzh$\\|\\.arc$\\|\\.zip$\\|\\.zoo$\\|\\.tar$\\|"
 703           "\\.dvi$\\|\\.ps$\\|\\.elc$\\|TAGS$\\|\\.gif$\\|"
 704           "\\.EXE\\(;[0-9]+\\)?$\\|\\.[zZ]-part-..$\\|\\.gz$\\|"
 705           "\\.taz$\\|\\.tgz$")
 706   "*If a file matches this regexp then it is transferred in binary mode.")
 707
 708 (defvar ange-ftp-gateway-host nil
 709   "*Name of host to use as gateway machine when local FTP isn't possible.")
 710
 711 (defvar ange-ftp-local-host-regexp ".*"
 712   "*Regexp selecting hosts which can be reached directly with ftp.
 713 For other hosts the FTP process is started on \`ange-ftp-gateway-host\'
 714 instead.")
 715
 716 (defvar ange-ftp-gateway-program-interactive nil
 717   "*If non-nil then the gateway program should  give a shell prompt.
 718 Both telnet and rlogin do something like this.")
 719
 720 (defvar ange-ftp-gateway-program (if (eq system-type 'hpux) "remsh" "rsh")
 721   "*Name of program to spawn a shell on the gateway machine.
 722 Valid candidates are rsh (remsh on hp-ux), telnet and rlogin.  See
 723 also the gateway variable above.")
 724
 725 (defvar ange-ftp-gateway-prompt-pattern "^[^#$%>;\n]*[#$%>;] *"
 726   "*Regexp matching prompt after complete login sequence on gateway machine.
 727 A match for this means the shell is now awaiting input.  Make this regexp as
 728 strict as possible; it shouldn't match *anything* at all except the user's
 729 initial prompt.  The above string will fail under most SUN-3's since it
 730 matches the login banner.")
 731
 732 (defvar ange-ftp-gateway-setup-term-command
 733   (if (eq system-type 'hpux)
 734       "stty -onlcr -echo\n"
 735     "stty -echo nl\n")
 736   "*Set up terminal after logging in to the gateway machine.
 737 This command should stop the terminal from echoing each command, and
 738 arrange to strip out trailing ^M characters.")
 739
 740 (defvar ange-ftp-smart-gateway nil
 741   "*Non-nil means the ftp gateway is smart.
 742 Don't bother telnetting, etc., just issue a user@host command instead.")
 743
 744 (defvar ange-ftp-smart-gateway-port "21"
 745   "*Port on gateway machine to use when smart gateway is in operation.")
 746
 747 (defvar ange-ftp-send-hash t
 748   "*If non-nil, send the HASH command to the FTP client.")
 749
 750 (defvar ange-ftp-binary-hash-mark-size nil
 751   "*Default size, in bytes, between hash-marks when transferring a binary file.
 752 If NIL, this variable will be locally overridden if the FTP client outputs a
 753 suitable response to the HASH command.  If non-NIL then this value takes
 754 precedence over the local value.")
 755
 756 (defvar ange-ftp-ascii-hash-mark-size 1024
 757   "*Default size, in bytes, between hash-marks when transferring an ASCII file.
 758 This variable is buffer-local and will be locally overridden if the FTP client
 759 outputs a suitable response to the HASH command.")
 760
 761 (defvar ange-ftp-process-verbose t
 762   "*If non-NIL then be chatty about interaction with the FTP process.")
 763
 764 (defvar ange-ftp-ftp-program-name "ftp"
 765   "*Name of FTP program to run.")
 766
 767 (defvar ange-ftp-gateway-ftp-program-name "ftp"
 768   "*Name of FTP program to run on gateway machine.
 769 Some AT&T folks claim to use something called `pftp' here.")
 770
 771 (defvar ange-ftp-ftp-program-args '("-i" "-n" "-g" "-v")
 772   "*A list of arguments passed to the FTP program when started.")
 773
 774 (defvar ange-ftp-nslookup-program nil
 775   "*If non-NIL then a string naming nslookup program." )
 776
 777 (defvar ange-ftp-make-backup-files ()
 778   "*Non-nil means make backup files for \"magic\" remote files.")
 779
 780 (defvar ange-ftp-retry-time 5
 781   "*Number of seconds to wait before retry if file or listing doesn't arrive.
 782 This might need to be increased for very slow connections.")
 783
 784 (defvar ange-ftp-auto-save 0
 785   "If 1, allows ange-ftp files to be auto-saved.
 786 If 0, suppresses auto-saving of ange-ftp files.
 787 Don't use any other value.")
 788 \f
 789 ;;;; ------------------------------------------------------------
 790 ;;;; Hash table support.
 791 ;;;; ------------------------------------------------------------
 792
 793 (require 'backquote)
 794
 795 (defun ange-ftp-make-hashtable (&optional size)
 796   "Make an obarray suitable for use as a hashtable.
 797 SIZE, if supplied, should be a prime number."
 798   (make-vector (or size 31) 0))
 799
 800 (defun ange-ftp-map-hashtable (fun tbl)
 801   "Call FUNCTION on each key and value in HASHTABLE."
 802   (mapatoms
 803    (function
 804     (lambda (sym)
 805       (funcall fun (get sym 'key) (get sym 'val))))
 806    tbl))
 807
 808 (defmacro ange-ftp-make-hash-key (key)
 809   "Convert KEY into a suitable key for a hashtable."
 810   (` (if (stringp (, key))
 811          (, key)
 812        (prin1-to-string (, key)))))
 813
 814 (defun ange-ftp-get-hash-entry (key tbl)
 815   "Return the value associated with KEY in HASHTABLE."
 816   (let ((sym (intern-soft (ange-ftp-make-hash-key key) tbl)))
 817     (and sym (get sym 'val))))
 818
 819 (defun ange-ftp-put-hash-entry (key val tbl)
 820   "Record an association between KEY and VALUE in HASHTABLE."
 821   (let ((sym (intern (ange-ftp-make-hash-key key) tbl)))
 822     (put sym 'val val)
 823     (put sym 'key key)))
 824
 825 (defun ange-ftp-del-hash-entry (key tbl)
 826   "Copy all symbols except KEY in HASHTABLE and return modified hashtable."
 827   (let* ((len (length tbl))
 828          (new-tbl (ange-ftp-make-hashtable len))
 829          (i (1- len)))
 830     (ange-ftp-map-hashtable
 831      (function
 832       (lambda (k v)
 833         (or (equal k key)
 834             (ange-ftp-put-hash-entry k v new-tbl))))
 835      tbl)
 836     (while (>= i 0)
 837       (aset tbl i (aref new-tbl i))
 838       (setq i (1- i)))
 839     tbl))
 840
 841 (defun ange-ftp-hash-entry-exists-p (key tbl)
 842   "Return whether there is an association for KEY in TABLE."
 843   (intern-soft (ange-ftp-make-hash-key key) tbl))
 844
 845 (defun ange-ftp-hash-table-keys (tbl)
 846   "Return a sorted list of all the active keys in TABLE, as strings."
 847   (sort (all-completions "" tbl)
 848         (function string-lessp)))
 849 \f
 850 ;;;; ------------------------------------------------------------
 851 ;;;; Internal variables.
 852 ;;;; ------------------------------------------------------------
 853
 854 (defconst ange-ftp-version "$Revision: 1.50 $")
 855
 856 (defvar ange-ftp-data-buffer-name " *ftp data*"
 857   "Buffer name to hold directory listing data received from ftp process.")
 858
 859 (defvar ange-ftp-netrc-modtime nil
 860   "Last modified time of the netrc file from file-attributes.")
 861
 862 (defvar ange-ftp-user-hashtable (ange-ftp-make-hashtable)
 863   "Hash table holding associations between HOST, USER pairs.")
 864
 865 (defvar ange-ftp-passwd-hashtable (ange-ftp-make-hashtable)
 866   "Mapping between a HOST, USER pair and a PASSWORD for them.")
 867
 868 (defvar ange-ftp-account-hashtable (ange-ftp-make-hashtable)
 869   "Mapping between a HOST, USER pair and a ACCOUNT password for them.")
 870
 871 (defvar ange-ftp-files-hashtable (ange-ftp-make-hashtable 97)
 872   "Hash table for storing directories and their respective files.")
 873
 874 (defvar ange-ftp-ls-cache-lsargs nil
 875   "Last set of args used by ange-ftp-ls.")
 876
 877 (defvar ange-ftp-ls-cache-file nil
 878   "Last file passed to ange-ftp-ls.")
 879
 880 (defvar ange-ftp-ls-cache-res nil
 881   "Last result returned from ange-ftp-ls.")
 882
 883 (defconst ange-ftp-expand-dir-hashtable (ange-ftp-make-hashtable))
 884
 885 (defconst ange-ftp-expand-dir-regexp "^5.0 \\([^: ]+\\):")
 886
 887 ;; These are local variables in each FTP process buffer.
 888 (defvar ange-ftp-hash-mark-unit nil)
 889 (defvar ange-ftp-hash-mark-count nil)
 890 (defvar ange-ftp-xfer-size nil)
 891 (defvar ange-ftp-process-string nil)
 892 (defvar ange-ftp-process-result-line nil)
 893 (defvar ange-ftp-process-busy nil)
 894 (defvar ange-ftp-process-result nil)
 895 (defvar ange-ftp-process-multi-skip nil)
 896 (defvar ange-ftp-process-msg nil)
 897 (defvar ange-ftp-process-continue nil)
 898 (defvar ange-ftp-last-percent nil)
 899
 900 ;; These variables are bound by one function and examined by another.
 901 ;; Leave them void globally for error checking.
 902 (defvar ange-ftp-this-file)
 903 (defvar ange-ftp-this-dir)
 904 (defvar ange-ftp-this-user)
 905 (defvar ange-ftp-this-host)
 906 (defvar ange-ftp-this-msg)
 907 (defvar ange-ftp-completion-ignored-pattern)
 908 (defvar ange-ftp-trample-marker)
 909 \f
 910 ;; New error symbols.
 911 (put 'ftp-error 'error-conditions '(ftp-error file-error error))
 912 ;; (put 'ftp-error 'error-message "FTP error")
 913 \f
 914 ;;; ------------------------------------------------------------
 915 ;;; Match-data support (stolen from Kyle I think)
 916 ;;; ------------------------------------------------------------
 917
 918 (defmacro ange-ftp-save-match-data (&rest body)
 919   "Execute the BODY forms, restoring the global value of the match data.
 920 Also makes matching case-sensitive within BODY."
 921   (let ((original (make-symbol "match-data"))
 922         case-fold-search)
 923     (list
 924      'let (list (list original '(match-data)))
 925      (list 'unwind-protect
 926            (cons 'progn body)
 927            (list 'store-match-data original)))))
 928
 929 (put 'ange-ftp-save-match-data 'lisp-indent-hook 0)
 930 (put 'ange-ftp-save-match-data 'edebug-form-hook '(&rest form))
 931 \f
 932 ;;; ------------------------------------------------------------
 933 ;;; Enhanced message support.
 934 ;;; ------------------------------------------------------------
 935
 936 (defun ange-ftp-message (fmt &rest args)
 937   "Display message in echo area, but indicate if truncated.
 938 Args are as in `message': a format string, plus arguments to be formatted."
 939   (let ((msg (apply (function format) fmt args))
 940         (max (window-width (minibuffer-window))))
 941     (if (>= (length msg) max)
 942         (setq msg (concat "> " (substring msg (- 3 max)))))
 943     (message "%s" msg)))
 944
 945 (defun ange-ftp-abbreviate-filename (file &optional new)
 946   "Abbreviate the file name FILE relative to the default-directory.
 947 If the optional parameter NEW is given and the non-directory parts match,
 948 only return the directory part of FILE."
 949   (ange-ftp-save-match-data
 950     (if (and default-directory
 951              (string-match (concat "^"
 952                                    (regexp-quote default-directory)
 953                                    ".") file))
 954         (setq file (substring file (1- (match-end 0)))))
 955     (if (and new
 956              (string-equal (file-name-nondirectory file)
 957                            (file-name-nondirectory new)))
 958         (setq file (file-name-directory file)))
 959     (or file "./")))
 960 \f
 961 ;;;; ------------------------------------------------------------
 962 ;;;; User / Host mapping support.
 963 ;;;; ------------------------------------------------------------
 964
 965 (defun ange-ftp-set-user (host user)
 966   "For a given HOST, set or change the default USER."
 967   (interactive "sHost: \nsUser: ")
 968   (ange-ftp-put-hash-entry host user ange-ftp-user-hashtable))
 969
 970 (defun ange-ftp-get-user (host)
 971   "Given a HOST, return the default USER."
 972   (ange-ftp-parse-netrc)
 973   (let ((user (ange-ftp-get-hash-entry host ange-ftp-user-hashtable)))
 974     (or user
 975         (prog1
 976             (setq user
 977                   (cond ((stringp ange-ftp-default-user)
 978                          ;; We have a default name.  Use it.
 979                          ange-ftp-default-user)
 980                         (ange-ftp-default-user
 981                          ;; Ask the user.
 982                          (let ((enable-recursive-minibuffers t))
 983                            (read-string (format "User for %s: " host)
 984                                         (user-login-name))))
 985                         ;; Default to the user's login name.
 986                         (t
 987                          (user-login-name))))
 988           (ange-ftp-set-user host user)))))
 989 \f
 990 ;;;; ------------------------------------------------------------
 991 ;;;; Password support.
 992 ;;;; ------------------------------------------------------------
 993
 994 (defun ange-ftp-read-passwd (prompt &optional default)
 995   "Read a password, echoing `.' for each character typed.
 996 End with RET, LFD, or ESC.  DEL or C-h rubs out.  C-u kills line.
 997 Optional DEFAULT is password to start with."
 998   (let ((pass (if default default ""))
 999         (c 0)
1000         (echo-keystrokes 0)
1001         (cursor-in-echo-area t))
1002     (while (progn (message "%s%s"
1003                            prompt
1004                            (make-string (length pass) ?.))
1005                   (setq c (read-char))
1006                   (and (/= c ?\r) (/= c ?\n) (/= c ?\e)))
1007       (if (= c ?\C-u)
1008           (setq pass "")
1009         (if (and (/= c ?\b) (/= c ?\177))
1010             (setq pass (concat pass (char-to-string c)))
1011           (if (> (length pass) 0)
1012               (setq pass (substring pass 0 -1))))))
1013     (message "")
1014     (ange-ftp-repaint-minibuffer)
1015     pass))
1016
1017 (defmacro ange-ftp-generate-passwd-key (host user)
1018   (` (concat (, host) "/" (, user))))
1019
1020 (defmacro ange-ftp-lookup-passwd (host user)
1021   (` (ange-ftp-get-hash-entry (ange-ftp-generate-passwd-key (, host) (, user))
1022                               ange-ftp-passwd-hashtable)))
1023
1024 (defun ange-ftp-set-passwd (host user passwd)
1025   "For a given HOST and USER, set or change the associated PASSWORD."
1026   (interactive (list (read-string "Host: ")
1027                      (read-string "User: ")
1028                      (ange-ftp-read-passwd "Password: ")))
1029   (ange-ftp-put-hash-entry (ange-ftp-generate-passwd-key host user)
1030                            passwd
1031                            ange-ftp-passwd-hashtable))
1032
1033 (defun ange-ftp-get-host-with-passwd (user)
1034   "Given a USER, return a host we know the password for."
1035   (ange-ftp-parse-netrc)
1036   (catch 'found-one
1037     (ange-ftp-map-hashtable
1038      (function (lambda (host val)
1039                  (if (ange-ftp-lookup-passwd host user)
1040                      (throw 'found-one host))))
1041      ange-ftp-user-hashtable)
1042     (ange-ftp-save-match-data
1043       (ange-ftp-map-hashtable
1044        (function
1045         (lambda (key value)
1046           (if (string-match "^[^/]*\\(/\\).*$" key)
1047               (let ((host (substring key 0 (match-beginning 1))))
1048                 (if (and (string-equal user (substring key (match-end 1)))
1049                          value)
1050                     (throw 'found-one host))))))
1051        ange-ftp-passwd-hashtable))
1052     nil))
1053
1054 (defun ange-ftp-get-passwd (host user)
1055   "Return the password for specified HOST and USER, asking user if necessary."
1056   (ange-ftp-parse-netrc)
1057
1058   ;; look up password in the hash table first; user might have overridden the
1059   ;; defaults.
1060   (cond ((ange-ftp-lookup-passwd host user))
1061
1062         ;; see if default user and password set from the .netrc file.
1063         ((and (stringp ange-ftp-default-user)
1064               ange-ftp-default-password
1065               (string-equal user ange-ftp-default-user))
1066          ange-ftp-default-password)
1067
1068         ;; anonymous ftp password is handled specially since there is an
1069         ;; unwritten rule about how that is used on the Internet.
1070         ((and (or (string-equal user "anonymous")
1071                   (string-equal user "ftp"))
1072               ange-ftp-generate-anonymous-password)
1073          (if (stringp ange-ftp-generate-anonymous-password)
1074              ange-ftp-generate-anonymous-password
1075            (concat (user-login-name) "@" (system-name))))
1076
1077         ;; see if same user has logged in to other hosts; if so then prompt
1078         ;; with the password that was used there.
1079         (t
1080          (let* ((other (ange-ftp-get-host-with-passwd user))
1081                 (passwd (if other
1082
1083                             ;; found another machine with the same user.
1084                             ;; Try that account.
1085                             (ange-ftp-read-passwd
1086                              (format "passwd for %s@%s (same as %s@%s): "
1087                                      user host user other)
1088                              (ange-ftp-lookup-passwd other user))
1089
1090                           ;; I give up.  Ask the user for the password.
1091                           (ange-ftp-read-passwd
1092                            (format "Password for %s@%s: " user host)))))
1093            (ange-ftp-set-passwd host user passwd)
1094            passwd))))
1095 \f
1096 ;;;; ------------------------------------------------------------
1097 ;;;; Account support
1098 ;;;; ------------------------------------------------------------
1099
1100 ;; Account passwords must be either specified in the .netrc file, or set
1101 ;; manually by calling ange-ftp-set-account.  For the moment, ange-ftp doesn't
1102 ;; check to see whether the FTP process is actually prompting for an account
1103 ;; password.
1104
1105 (defun ange-ftp-set-account (host user account)
1106   "For a given HOST and USER, set or change the associated ACCOUNT password."
1107   (interactive (list (read-string "Host: ")
1108                      (read-string "User: ")
1109                      (ange-ftp-read-passwd "Account password: ")))
1110   (ange-ftp-put-hash-entry (ange-ftp-generate-passwd-key host user)
1111                            account
1112                            ange-ftp-account-hashtable))
1113
1114 (defun ange-ftp-get-account (host user)
1115   "Given a HOST and USER, return the FTP account."
1116   (ange-ftp-parse-netrc)
1117   (or (ange-ftp-get-hash-entry (ange-ftp-generate-passwd-key host user)
1118                                ange-ftp-account-hashtable)
1119       (and (stringp ange-ftp-default-user)
1120            (string-equal user ange-ftp-default-user)
1121            ange-ftp-default-account)))
1122 \f
1123 ;;;; ------------------------------------------------------------
1124 ;;;; ~/.netrc support
1125 ;;;; ------------------------------------------------------------
1126
1127 (defun ange-ftp-chase-symlinks (file)
1128   "Return the filename that FILE references, following all symbolic links."
1129   (let (temp)
1130     (while (setq temp (ange-ftp-real-file-symlink-p file))
1131       (setq file
1132             (if (file-name-absolute-p temp)
1133                 temp
1134               (concat (file-name-directory file) temp)))))
1135   file)
1136
1137 ;; Move along current line looking for the value of the TOKEN.
1138 ;; Valid separators between TOKEN and its value are commas and
1139 ;; whitespace.  Second arg LIMIT is a limit for the search.
1140
1141 (defun ange-ftp-parse-netrc-token (token limit)
1142   (if (search-forward token limit t)
1143       (let (beg)
1144         (skip-chars-forward ", \t\r\n" limit)
1145         (if (eq (following-char) ?\")   ;quoted token value
1146             (progn (forward-char 1)
1147                    (setq beg (point))
1148                    (skip-chars-forward "^\"" limit)
1149                    (forward-char 1)
1150                    (buffer-substring beg (1- (point))))
1151           (setq beg (point))
1152           (skip-chars-forward "^, \t\r\n" limit)
1153           (buffer-substring beg (point))))))
1154
1155 ;; Extract the values for the tokens `machine', `login',
1156 ;; `password' and `account' in the current buffer.  If successful,
1157 ;; record the information found.
1158
1159 (defun ange-ftp-parse-netrc-group ()
1160   (beginning-of-line)
1161   (let ((start (point))
1162         (end (progn (re-search-forward "machine\\|default"
1163                                        (point-max) 'end 2) (point)))
1164         machine login password account)
1165     (goto-char start)
1166     (setq machine  (ange-ftp-parse-netrc-token "machine"  end)
1167           login    (ange-ftp-parse-netrc-token "login"    end)
1168           password (ange-ftp-parse-netrc-token "password" end)
1169           account  (ange-ftp-parse-netrc-token "account"  end))
1170     (if (and machine login)
1171         ;; found a `machine` token.
1172         (progn
1173           (ange-ftp-set-user machine login)
1174           (ange-ftp-set-passwd machine login password)
1175           (and account
1176                (ange-ftp-set-account machine login account)))
1177       (goto-char start)
1178       (if (search-forward "default" end t)
1179           ;; found a `default' token
1180           (progn
1181             (setq login    (ange-ftp-parse-netrc-token "login"    end)
1182                   password (ange-ftp-parse-netrc-token "password" end)
1183                   account  (ange-ftp-parse-netrc-token "account"  end))
1184             (and login
1185                  (setq ange-ftp-default-user login))
1186             (and password
1187                  (setq ange-ftp-default-password password))
1188             (and account
1189                  (setq ange-ftp-default-account account)))))
1190     (goto-char end)))
1191
1192 ;; Read in ~/.netrc, if one exists.  If ~/.netrc file exists and has
1193 ;; the correct permissions then extract the \`machine\', \`login\',
1194 ;; \`password\' and \`account\' information from within.
1195
1196 (defun ange-ftp-parse-netrc ()
1197   ;; We set this before actually doing it to avoid the possibility
1198   ;; of an infinite loop if ange-ftp-netrc-filename is an FTP file.
1199   (interactive)
1200   (let* ((file (ange-ftp-chase-symlinks
1201                 (ange-ftp-real-expand-file-name ange-ftp-netrc-filename)))
1202          (attr (ange-ftp-real-file-attributes file)))
1203     (if (and attr                       ; file exists.
1204              (not (equal (nth 5 attr) ange-ftp-netrc-modtime))) ; file changed
1205         (ange-ftp-save-match-data
1206           (if (or ange-ftp-disable-netrc-security-check
1207                   (and (eq (nth 2 attr) (user-uid)) ; Same uids.
1208                        (string-match ".r..------" (nth 8 attr))))
1209               (save-excursion
1210                 ;; we are cheating a bit here.  I'm trying to do the equivalent
1211                 ;; of find-file on the .netrc file, but then nuke it afterwards.
1212                 ;; with the bit of logic below we should be able to have
1213                 ;; encrypted .netrc files.
1214                 (set-buffer (generate-new-buffer "*ftp-.netrc*"))
1215                 (ange-ftp-real-insert-file-contents file)
1216                 (setq buffer-file-name file)
1217                 (setq default-directory (file-name-directory file))
1218                 (normal-mode t)
1219                 (mapcar 'funcall find-file-hooks)
1220                 (setq buffer-file-name nil)
1221                 (goto-char (point-min))
1222                 (while (not (eobp))
1223                   (ange-ftp-parse-netrc-group))
1224                 (kill-buffer (current-buffer)))
1225             (ange-ftp-message "%s either not owned by you or badly protected."
1226                               ange-ftp-netrc-filename)
1227             (sit-for 1))
1228           (setq ange-ftp-netrc-modtime (nth 5 attr))))))
1229
1230 ;; Return a list of prefixes of the form 'user@host:' to be used when
1231 ;; completion is done in the root directory.
1232
1233 (defun ange-ftp-generate-root-prefixes ()
1234   (ange-ftp-parse-netrc)
1235   (ange-ftp-save-match-data
1236     (let (res)
1237       (ange-ftp-map-hashtable
1238        (function
1239         (lambda (key value)
1240           (if (string-match "^[^/]*\\(/\\).*$" key)
1241               (let ((host (substring key 0 (match-beginning 1)))
1242                     (user (substring key (match-end 1))))
1243                 (setq res (cons (list (concat user "@" host ":"))
1244                                 res))))))
1245        ange-ftp-passwd-hashtable)
1246       (ange-ftp-map-hashtable
1247        (function (lambda (host user)
1248                    (setq res (cons (list (concat host ":"))
1249                                    res))))
1250        ange-ftp-user-hashtable)
1251       (or res (list nil)))))
1252 \f
1253 ;;;; ------------------------------------------------------------
1254 ;;;; Remote file name syntax support.
1255 ;;;; ------------------------------------------------------------
1256
1257 (defmacro ange-ftp-ftp-name-component (n ns name)
1258   "Extract the Nth ftp file name component from NS."
1259   (` (let ((elt (nth (, n) (, ns))))
1260        (if (match-beginning elt)
1261            (substring (, name) (match-beginning elt) (match-end elt))))))
1262
1263 (defvar ange-ftp-ftp-name-arg "")
1264 (defvar ange-ftp-ftp-name-res nil)
1265
1266 ;; Parse NAME according to `ange-ftp-name-format' (which see).
1267 ;; Returns a list (HOST USER NAME), or nil if NAME does not match the format.
1268 (defun ange-ftp-ftp-name (name)
1269   (if (string-equal name ange-ftp-ftp-name-arg)
1270       ange-ftp-ftp-name-res
1271     (setq ange-ftp-ftp-name-arg name
1272           ange-ftp-ftp-name-res
1273           (ange-ftp-save-match-data
1274             (if (string-match (car ange-ftp-name-format) name)
1275                 (let* ((ns (cdr ange-ftp-name-format))
1276                        (host (ange-ftp-ftp-name-component 0 ns name))
1277                        (user (ange-ftp-ftp-name-component 1 ns name))
1278                        (name (ange-ftp-ftp-name-component 2 ns name)))
1279                   (if (zerop (length user))
1280                       (setq user (ange-ftp-get-user host)))
1281                   (list host user name))
1282               nil)))))
1283
1284 ;; Take a FULLNAME that matches according to ange-ftp-name-format and
1285 ;; replace the name component with NAME.
1286 (defun ange-ftp-replace-name-component (fullname name)
1287   (ange-ftp-save-match-data
1288     (if (string-match (car ange-ftp-name-format) fullname)
1289         (let* ((ns (cdr ange-ftp-name-format))
1290                (elt (nth 2 ns)))
1291           (concat (substring fullname 0 (match-beginning elt))
1292                   name
1293                   (substring fullname (match-end elt)))))))
1294 \f
1295 ;;;; ------------------------------------------------------------
1296 ;;;; Miscellaneous utils.
1297 ;;;; ------------------------------------------------------------
1298
1299 ;; (setq ange-ftp-tmp-keymap (make-sparse-keymap))
1300 ;; (define-key ange-ftp-tmp-keymap "\C-m" 'exit-minibuffer)
1301
1302 (defun ange-ftp-repaint-minibuffer ()
1303   "Clear any existing minibuffer message; let the minibuffer contents show."
1304   (message nil))
1305
1306 ;; Return the name of the buffer that collects output from the ftp process
1307 ;; connected to the given HOST and USER pair.
1308 (defun ange-ftp-ftp-process-buffer (host user)
1309   (concat "*ftp " user "@" host "*"))
1310
1311 ;; Display the last chunk of output from the ftp process for the given HOST
1312 ;; USER pair, and signal an error including MSG in the text.
1313 (defun ange-ftp-error (host user msg)
1314   (let ((cur (selected-window))
1315         (pop-up-windows t))
1316     (pop-to-buffer
1317      (get-buffer-create
1318       (ange-ftp-ftp-process-buffer host user)))
1319     (goto-char (point-max))
1320     (select-window cur))
1321   (signal 'ftp-error (list (format "FTP Error: %s" msg))))
1322
1323 (defun ange-ftp-set-buffer-mode ()
1324   "Set correct modes for the current buffer if visiting a remote file."
1325   (if (and (stringp buffer-file-name)
1326            (ange-ftp-ftp-name buffer-file-name))
1327       (progn
1328         (make-local-variable 'make-backup-files)
1329         (setq make-backup-files ange-ftp-make-backup-files)
1330         (auto-save-mode ange-ftp-auto-save))))
1331
1332 (defun ange-ftp-kill-ftp-process (buffer)
1333   "Kill the FTP process associated with BUFFER.
1334 If the BUFFER's visited filename or default-directory is an ftp filename
1335 then kill the related ftp process."
1336   (interactive "bKill FTP process associated with buffer: ")
1337   (if (null buffer)
1338       (setq buffer (current-buffer)))
1339   (let ((file (or (buffer-file-name) default-directory)))
1340     (if file
1341         (let ((parsed (ange-ftp-ftp-name (expand-file-name file))))
1342           (if parsed
1343               (let ((host (nth 0 parsed))
1344                     (user (nth 1 parsed)))
1345                 (kill-buffer (ange-ftp-ftp-process-buffer host user))))))))
1346
1347 (defun ange-ftp-quote-string (string)
1348   "Quote any characters in STRING that may confuse the ftp process."
1349   (apply (function concat)
1350          (mapcar (function
1351                    (lambda (char)
1352                      (if (or (<= char ? )
1353                              (> char ?\~)
1354                              (= char ?\")
1355                              (= char ?\\))
1356                          (vector ?\\ char)
1357                        (vector char))))
1358                  string)))
1359
1360 (defun ange-ftp-barf-if-not-directory (directory)
1361   (or (file-directory-p directory)
1362       (signal 'file-error
1363               (list "Opening directory"
1364                     (if (file-exists-p directory)
1365                         "not a directory"
1366                       "no such file or directory")
1367                     directory))))
1368 \f
1369 ;;;; ------------------------------------------------------------
1370 ;;;; FTP process filter support.
1371 ;;;; ------------------------------------------------------------
1372
1373 (defun ange-ftp-process-handle-line (line proc)
1374   "Look at the given LINE from the ftp process PROC.
1375 Try to categorize it into one of four categories:
1376 good, skip, fatal, or unknown."
1377   (cond ((string-match ange-ftp-xfer-size-msgs line)
1378          (setq ange-ftp-xfer-size
1379                (ash (string-to-int (substring line
1380                                               (match-beginning 1)
1381                                               (match-end 1)))
1382                     -10)))
1383         ((string-match ange-ftp-skip-msgs line)
1384          t)
1385         ((string-match ange-ftp-good-msgs line)
1386          (setq ange-ftp-process-busy nil
1387                ange-ftp-process-result t
1388                ange-ftp-process-result-line line))
1389         ((string-match ange-ftp-fatal-msgs line)
1390          (delete-process proc)
1391          (setq ange-ftp-process-busy nil
1392                ange-ftp-process-result-line line))
1393         ((string-match ange-ftp-multi-msgs line)
1394          (setq ange-ftp-process-multi-skip t))
1395         (ange-ftp-process-multi-skip
1396          t)
1397         (t
1398          (setq ange-ftp-process-busy nil
1399                ange-ftp-process-result-line line))))
1400
1401 (defun ange-ftp-set-xfer-size (host user bytes)
1402   "Set the size of the next FTP transfer in bytes."
1403   (let ((proc (ange-ftp-get-process host user)))
1404     (if proc
1405         (let ((buf (process-buffer proc)))
1406           (if buf
1407               (save-excursion
1408                 (set-buffer buf)
1409                 (setq ange-ftp-xfer-size (ash bytes -10))))))))
1410
1411 (defun ange-ftp-process-handle-hash (str)
1412   "Remove hash marks from STRING and display count so far."
1413   (setq str (concat (substring str 0 (match-beginning 0))
1414                     (substring str (match-end 0)))
1415         ange-ftp-hash-mark-count (+ (- (match-end 0)
1416                                        (match-beginning 0))
1417                                     ange-ftp-hash-mark-count))
1418   (and ange-ftp-process-msg
1419        ange-ftp-process-verbose
1420        (not (eq (selected-window) (minibuffer-window)))
1421        (not (boundp 'search-message))   ;screws up isearch otherwise
1422        (not cursor-in-echo-area)        ;screws up y-or-n-p otherwise
1423        (let ((kbytes (ash (* ange-ftp-hash-mark-unit
1424                              ange-ftp-hash-mark-count)
1425                           -6)))
1426        (if (zerop ange-ftp-xfer-size)
1427            (ange-ftp-message "%s...%dk" ange-ftp-process-msg kbytes)
1428          (let ((percent (/ (* 100 kbytes) ange-ftp-xfer-size)))
1429            ;; cut out the redisplay of identical %-age messages.
1430            (if (not (eq percent ange-ftp-last-percent))
1431                (progn
1432                  (setq ange-ftp-last-percent percent)
1433                  (ange-ftp-message "%s...%d%%" ange-ftp-process-msg percent)))))))
1434   str)
1435
1436 ;; Call the function specified by CONT.  CONT can be either a function
1437 ;; or a list of a function and some args.  The first two parameters
1438 ;; passed to the function will be RESULT and LINE.  The remaining args
1439 ;; will be taken from CONT if a list was passed.
1440
1441 (defun ange-ftp-call-cont (cont result line)
1442   (if cont
1443       (if (and (listp cont)
1444                (not (eq (car cont) 'lambda)))
1445           (apply (car cont) result line (cdr cont))
1446         (funcall cont result line))))
1447
1448 ;; Build up a complete line of output from the ftp PROCESS and pass it
1449 ;; on to ange-ftp-process-handle-line to deal with.
1450
1451 (defun ange-ftp-process-filter (proc str)
1452   (let ((buffer (process-buffer proc))
1453         (old-buffer (current-buffer)))
1454
1455     ;; see if the buffer is still around... it could have been deleted.
1456     (if (buffer-name buffer)
1457         (unwind-protect
1458             (ange-ftp-save-match-data
1459               (set-buffer (process-buffer proc))
1460
1461               ;; handle hash mark printing
1462               (and ange-ftp-hash-mark-unit
1463                    ange-ftp-process-busy
1464                    (string-match "^#+$" str)
1465                    (setq str (ange-ftp-process-handle-hash str)))
1466               (comint-output-filter proc str)
1467               (if ange-ftp-process-busy
1468                   (progn
1469                     (setq ange-ftp-process-string (concat ange-ftp-process-string
1470                                                           str))
1471
1472                     ;; if we gave an empty password to the USER command earlier
1473                     ;; then we should send a null password now.
1474                     (if (string-match "Password: *$" ange-ftp-process-string)
1475                         (send-string proc "\n"))))
1476               (while (and ange-ftp-process-busy
1477                           (string-match "\n" ange-ftp-process-string))
1478                 (let ((line (substring ange-ftp-process-string
1479                                        0
1480                                        (match-beginning 0))))
1481                   (setq ange-ftp-process-string (substring ange-ftp-process-string
1482                                                            (match-end 0)))
1483                   (while (string-match "^ftp> *" line)
1484                     (setq line (substring line (match-end 0))))
1485                   (ange-ftp-process-handle-line line proc)))
1486
1487               ;; has the ftp client finished?  if so then do some clean-up
1488               ;; actions.
1489               (if (not ange-ftp-process-busy)
1490                   (progn
1491                     ;; reset the xfer size
1492                     (setq ange-ftp-xfer-size 0)
1493
1494                     ;; issue the "done" message since we've finished.
1495                     (if (and ange-ftp-process-msg
1496                              ange-ftp-process-verbose
1497                              ange-ftp-process-result)
1498                         (progn
1499                           (ange-ftp-message "%s...done" ange-ftp-process-msg)
1500                           (ange-ftp-repaint-minibuffer)
1501                           (setq ange-ftp-process-msg nil)))
1502
1503                     ;; is there a continuation we should be calling?  if so,
1504                     ;; we'd better call it, making sure we only call it once.
1505                     (if ange-ftp-process-continue
1506                         (let ((cont ange-ftp-process-continue))
1507                           (setq ange-ftp-process-continue nil)
1508                           (ange-ftp-call-cont cont
1509                                               ange-ftp-process-result
1510                                               ange-ftp-process-result-line))))))
1511           (set-buffer old-buffer)))))
1512
1513 (defun ange-ftp-process-sentinel (proc str)
1514   "When ftp process changes state, nuke all file-entries in cache."
1515   (ange-ftp-save-match-data
1516     (let ((name (process-name proc)))
1517       (if (string-match "\\*ftp \\([^@]+\\)@\\([^*]+\\)*" name)
1518           (let ((user (substring name (match-beginning 1) (match-end 1)))
1519                 (host (substring name (match-beginning 2) (match-end 2))))
1520             (ange-ftp-wipe-file-entries host user))))
1521     (setq ange-ftp-ls-cache-file nil)))
1522 \f
1523 ;;;; ------------------------------------------------------------
1524 ;;;; Gateway support.
1525 ;;;; ------------------------------------------------------------
1526
1527 (defun ange-ftp-use-gateway-p (host)
1528   "Returns whether to access this host via a normal (non-smart) gateway."
1529   ;; yes, I know that I could simplify the following expression, but it is
1530   ;; clearer (to me at least) this way.
1531   (and (not ange-ftp-smart-gateway)
1532        (ange-ftp-save-match-data
1533          (not (string-match ange-ftp-local-host-regexp host)))))
1534
1535 (defun ange-ftp-use-smart-gateway-p (host)
1536   "Returns whether to access this host via a smart gateway."
1537   (and ange-ftp-smart-gateway
1538        (ange-ftp-save-match-data
1539          (not (string-match ange-ftp-local-host-regexp host)))))
1540
1541 \f
1542 ;;; ------------------------------------------------------------
1543 ;;; Temporary file location and deletion...
1544 ;;; ------------------------------------------------------------
1545
1546 (defvar ange-ftp-tmp-name-files ())
1547 (defvar ange-ftp-tmp-name-hashtable (ange-ftp-make-hashtable 10))
1548 (defvar ange-ftp-pid nil)
1549
1550 (defun ange-ftp-get-pid ()
1551   "Half-hearted attempt to get the current process's id."
1552   (setq ange-ftp-pid (substring (make-temp-name "") 1)))
1553
1554 (defun ange-ftp-make-tmp-name (host)
1555   "This routine will return the name of a new file."
1556   (let* ((template (if (ange-ftp-use-gateway-p host)
1557                        ange-ftp-gateway-tmp-name-template
1558                      ange-ftp-tmp-name-template))
1559          (pid (or ange-ftp-pid (ange-ftp-get-pid)))
1560          (start ?a)
1561          file entry)
1562     (while
1563         (progn
1564           (setq file (format "%s%c%s" template start pid))
1565           (setq entry (intern file ange-ftp-tmp-name-hashtable))
1566           (or (memq entry ange-ftp-tmp-name-files)
1567               (ange-ftp-real-file-exists-p file)))
1568       (if (> (setq start (1+ start)) ?z)
1569           (progn
1570             (setq template (concat template "X"))
1571             (setq start ?a))))
1572     (setq ange-ftp-tmp-name-files
1573           (cons entry ange-ftp-tmp-name-files))
1574     file))
1575
1576 (defun ange-ftp-del-tmp-name (temp)
1577   (setq ange-ftp-tmp-name-files
1578         (delq (intern temp ange-ftp-tmp-name-hashtable)
1579               ange-ftp-tmp-name-files))
1580   (condition-case ()
1581       (ange-ftp-real-delete-file temp)
1582     (error nil)))
1583 \f
1584 ;;;; ------------------------------------------------------------
1585 ;;;; Interactive gateway program support.
1586 ;;;; ------------------------------------------------------------
1587
1588 (defvar ange-ftp-gwp-running t)
1589 (defvar ange-ftp-gwp-status nil)
1590
1591 (defun ange-ftp-gwp-sentinel (proc str)
1592   (setq ange-ftp-gwp-running nil))
1593
1594 (defun ange-ftp-gwp-filter (proc str)
1595   (ange-ftp-save-match-data
1596     (comint-output-filter proc str)
1597     (cond ((string-match "login: *$" str)
1598            (send-string proc
1599                         (concat
1600                          (let ((ange-ftp-default-user t))
1601                            (ange-ftp-get-user ange-ftp-gateway-host))
1602                          "\n")))
1603           ((string-match "Password: *$" str)
1604            (send-string proc
1605                         (concat
1606                          (ange-ftp-get-passwd ange-ftp-gateway-host
1607                                               (ange-ftp-get-user
1608                                                ange-ftp-gateway-host))
1609                          "\n")))
1610           ((string-match ange-ftp-gateway-fatal-msgs str)
1611            (delete-process proc)
1612            (setq ange-ftp-gwp-running nil))
1613           ((string-match ange-ftp-gateway-prompt-pattern str)
1614            (setq ange-ftp-gwp-running nil
1615                  ange-ftp-gwp-status t)))))
1616
1617 (defun ange-ftp-gwp-start (host user name args)
1618   "Login to the gateway machine and fire up an ftp process."
1619   (let* ((gw-user (ange-ftp-get-user ange-ftp-gateway-host))
1620          ;; It would be nice to make process-connection-type nil,
1621          ;; but that doesn't work: ftp never responds.
1622          ;; Can anyone find a fix for that?
1623          (proc (let ((process-connection-type t))
1624                  (start-process name name
1625                                 ange-ftp-gateway-program
1626                                 ange-ftp-gateway-host)))
1627          (ftp (mapconcat (function identity) args " ")))
1628     (process-kill-without-query proc)
1629     (set-process-sentinel proc (function ange-ftp-gwp-sentinel))
1630     (set-process-filter proc (function ange-ftp-gwp-filter))
1631     (set-marker (process-mark proc) (point))
1632     (setq ange-ftp-gwp-running t
1633           ange-ftp-gwp-status nil)
1634     (ange-ftp-message "Connecting to gateway %s..." ange-ftp-gateway-host)
1635     (while ange-ftp-gwp-running         ;perform login sequence
1636       (accept-process-output proc))
1637     (if (not ange-ftp-gwp-status)
1638         (ange-ftp-error host user "unable to login to gateway"))
1639     (ange-ftp-message "Connecting to gateway %s...done" ange-ftp-gateway-host)
1640     (setq ange-ftp-gwp-running t
1641           ange-ftp-gwp-status nil)
1642     (process-send-string proc ange-ftp-gateway-setup-term-command)
1643     (while ange-ftp-gwp-running         ;zap ^M's and double echoing.
1644       (accept-process-output proc))
1645     (if (not ange-ftp-gwp-status)
1646         (ange-ftp-error host user "unable to set terminal modes on gateway"))
1647     (setq ange-ftp-gwp-running t
1648           ange-ftp-gwp-status nil)
1649     (process-send-string proc (concat "exec " ftp "\n")) ;spawn ftp process
1650     proc))
1651 \f
1652 ;;;; ------------------------------------------------------------
1653 ;;;; Support for sending commands to the ftp process.
1654 ;;;; ------------------------------------------------------------
1655
1656 (defun ange-ftp-raw-send-cmd (proc cmd &optional msg cont nowait)
1657   "Low-level routine to send the given ftp CMD to the ftp PROCESS.
1658 MSG is an optional message to output before and after the command.
1659 If CONT is non-NIL then it is either a function or a list of function and
1660 some arguments.  The function will be called when the ftp command has completed.
1661 If CONT is NIL then this routine will return \( RESULT . LINE \) where RESULT
1662 is whether the command was successful, and LINE is the line from the FTP
1663 process that caused the command to complete.
1664 If NOWAIT is given then the routine will return immediately the command has
1665 been queued with no result.  CONT will still be called, however."
1666   (if (memq (process-status proc) '(run open))
1667       (save-excursion
1668         (set-buffer (process-buffer proc))
1669         (while ange-ftp-process-busy
1670           ;; This is a kludge to let user quit in case ftp gets hung.
1671           ;; It matters because this function can be called from the filter.
1672           ;; It is bad to allow quitting in a filter, but getting hung
1673           ;; is worse.  By binding quit-flag to nil, we might avoid
1674           ;; most of the probability of getting screwed because the user
1675           ;; wants to quit some command.
1676           (let ((quit-flag nil)
1677                 (inhibit-quit nil))
1678             (accept-process-output)))
1679         (setq ange-ftp-process-string ""
1680               ange-ftp-process-result-line ""
1681               ange-ftp-process-busy t
1682               ange-ftp-process-result nil
1683               ange-ftp-process-multi-skip nil
1684               ange-ftp-process-msg msg
1685               ange-ftp-process-continue cont
1686               ange-ftp-hash-mark-count 0
1687               ange-ftp-last-percent -1
1688               cmd (concat cmd "\n"))
1689         (and msg ange-ftp-process-verbose (ange-ftp-message "%s..." msg))
1690         (goto-char (point-max))
1691         (move-marker comint-last-input-start (point))
1692         ;; don't insert the password into the buffer on the USER command.
1693         (ange-ftp-save-match-data
1694           (if (string-match "^user \"[^\"]*\"" cmd)
1695               (insert (substring cmd 0 (match-end 0)) " Turtle Power!\n")
1696             (insert cmd)))
1697         (move-marker comint-last-input-end (point))
1698         (send-string proc cmd)
1699         (set-marker (process-mark proc) (point))
1700         (if nowait
1701             nil
1702           ;; hang around for command to complete
1703           (while ange-ftp-process-busy
1704             ;; This is a kludge to let user quit in case ftp gets hung.
1705             ;; It matters because this function can be called from the filter.
1706             (let ((quit-flag nil)
1707                   (inhibit-quit nil))
1708               (accept-process-output proc)))
1709           (if cont
1710               nil                       ;cont has already been called
1711             (cons ange-ftp-process-result ange-ftp-process-result-line))))))
1712
1713 (defun ange-ftp-nslookup-host (host)
1714   "Attempt to resolve the given HOSTNAME using nslookup if possible."
1715   (interactive "sHost:  ")
1716   (if ange-ftp-nslookup-program
1717       (let ((default-directory
1718               (if (file-accessible-directory-p default-directory)
1719                   default-directory
1720                 exec-directory))
1721             ;; It would be nice to make process-connection-type nil,
1722             ;; but that doesn't work: ftp never responds.
1723             ;; Can anyone find a fix for that?
1724             (proc (let ((process-connection-type t))
1725                     (start-process " *nslookup*" " *nslookup*"
1726                                    ange-ftp-nslookup-program host)))
1727             (res host))
1728         (process-kill-without-query proc)
1729         (save-excursion
1730           (set-buffer (process-buffer proc))
1731           (while (memq (process-status proc) '(run open))
1732             (accept-process-output proc))
1733           (goto-char (point-min))
1734           (if (re-search-forward "Name:.*\nAddress: *\\(.*\\)$" nil t)
1735               (setq res (buffer-substring (match-beginning 1)
1736                                           (match-end 1))))
1737           (kill-buffer (current-buffer)))
1738         res)
1739     host))
1740
1741 (defun ange-ftp-start-process (host user name)
1742   "Spawn a new ftp process ready to connect to machine HOST and give it NAME.
1743 If HOST is only ftp-able through a gateway machine then spawn a shell
1744 on the gateway machine to do the ftp instead."
1745   (let* ((use-gateway (ange-ftp-use-gateway-p host))
1746          (ftp-prog (if use-gateway
1747                        ange-ftp-gateway-ftp-program-name
1748                      ange-ftp-ftp-program-name))
1749          (args (append (list ftp-prog) ange-ftp-ftp-program-args))
1750          ;; Without the following binding, ange-ftp-start-process
1751          ;; recurses on file-accessible-directory-p, since it needs to
1752          ;; restart its process in order to determine anything about
1753          ;; default-directory.
1754          (file-name-handler-alist)
1755          (default-directory
1756            (if (file-accessible-directory-p default-directory)
1757                default-directory
1758              exec-directory))
1759          proc)
1760     ;; It would be nice to make process-connection-type nil,
1761     ;; but that doesn't work: ftp never responds.
1762     ;; Can anyone find a fix for that?
1763     (let ((process-connection-type t))
1764       (if use-gateway
1765           (if ange-ftp-gateway-program-interactive
1766               (setq proc (ange-ftp-gwp-start host user name args))
1767             (setq proc (apply 'start-process name name
1768                               (append (list ange-ftp-gateway-program
1769                                             ange-ftp-gateway-host)
1770                                       args))))
1771         (setq proc (apply 'start-process name name args))))
1772     (process-kill-without-query proc)
1773     (save-excursion
1774       (set-buffer (process-buffer proc))
1775       (internal-ange-ftp-mode))
1776     (set-process-sentinel proc (function ange-ftp-process-sentinel))
1777     (set-process-filter proc (function ange-ftp-process-filter))
1778     (accept-process-output proc)        ;wait for ftp startup message
1779     proc))
1780
1781 (defun internal-ange-ftp-mode ()
1782   "Major mode for interacting with the FTP process.
1783
1784 \\{comint-mode-map}"
1785   (interactive)
1786   (comint-mode)
1787   (setq major-mode 'internal-ange-ftp-mode)
1788   (setq mode-name "Internal Ange-ftp")
1789   (let ((proc (get-buffer-process (current-buffer))))
1790     (goto-char (point-max))
1791     (set-marker (process-mark proc) (point))
1792     (make-local-variable 'ange-ftp-process-string)
1793     (setq ange-ftp-process-string "")
1794     (make-local-variable 'ange-ftp-process-busy)
1795     (make-local-variable 'ange-ftp-process-result)
1796     (make-local-variable 'ange-ftp-process-msg)
1797     (make-local-variable 'ange-ftp-process-multi-skip)
1798     (make-local-variable 'ange-ftp-process-result-line)
1799     (make-local-variable 'ange-ftp-process-continue)
1800     (make-local-variable 'ange-ftp-hash-mark-count)
1801     (make-local-variable 'ange-ftp-binary-hash-mark-size)
1802     (make-local-variable 'ange-ftp-ascii-hash-mark-size)
1803     (make-local-variable 'ange-ftp-hash-mark-unit)
1804     (make-local-variable 'ange-ftp-xfer-size)
1805     (make-local-variable 'ange-ftp-last-percent)
1806     (setq ange-ftp-hash-mark-count 0)
1807     (setq ange-ftp-xfer-size 0)
1808     (setq ange-ftp-process-result-line "")
1809
1810     (setq comint-prompt-regexp "^ftp> ")
1811     (make-local-variable 'paragraph-start)
1812     (setq paragraph-start comint-prompt-regexp)))
1813
1814 (defun ange-ftp-smart-login (host user pass account proc)
1815   "Connect to the FTP-server on HOST as USER using PASSWORD and ACCOUNT.
1816 PROC is the FTP-client's process.  This routine uses the smart-gateway
1817 host specified in ``ange-ftp-gateway-host''."
1818   (let ((result (ange-ftp-raw-send-cmd
1819                  proc
1820                  (format "open %s %s"
1821                          (ange-ftp-nslookup-host ange-ftp-gateway-host)
1822                          ange-ftp-smart-gateway-port)
1823                  (format "Opening FTP connection to %s via %s"
1824                          host
1825                          ange-ftp-gateway-host))))
1826     (or (car result)
1827         (ange-ftp-error host user
1828                         (concat "OPEN request failed: "
1829                                 (cdr result))))
1830     (setq result (ange-ftp-raw-send-cmd
1831                   proc (format "user \"%s\"@%s %s %s"
1832                                user
1833                                (ange-ftp-nslookup-host host)
1834                                pass
1835                                account)
1836                   (format "Logging in as user %s@%s"
1837                           user host)))
1838     (or (car result)
1839         (progn
1840           (ange-ftp-set-passwd host user nil) ; reset password
1841           (ange-ftp-set-account host user nil) ; reset account
1842           (ange-ftp-error host user
1843                           (concat "USER request failed: "
1844                                   (cdr result)))))))
1845
1846 (defun ange-ftp-normal-login (host user pass account proc)
1847   "Connect to the FTP-server on HOST as USER using PASSWORD and ACCOUNT.
1848 PROC is the process to the FTP-client."
1849   (let ((result (ange-ftp-raw-send-cmd
1850                  proc
1851                  (format "open %s" (ange-ftp-nslookup-host host))
1852                  (format "Opening FTP connection to %s" host))))
1853     (or (car result)
1854         (ange-ftp-error host user
1855                         (concat "OPEN request failed: "
1856                                 (cdr result))))
1857     (setq result (ange-ftp-raw-send-cmd
1858                   proc
1859                   (format "user \"%s\" %s %s" user pass account)
1860                   (format "Logging in as user %s@%s" user host)))
1861     (or (car result)
1862         (progn
1863           (ange-ftp-set-passwd host user nil) ;reset password.
1864           (ange-ftp-set-account host user nil) ;reset account.
1865           (ange-ftp-error host user
1866                           (concat "USER request failed: "
1867                                   (cdr result)))))))
1868
1869 ;; ange@hplb.hpl.hp.com says this should not be changed.
1870 (defvar ange-ftp-hash-mark-msgs
1871   "[hH]ash mark [^0-9]*\\([0-9]+\\)"
1872   "*Regexp matching the FTP client's output upon doing a HASH command.")
1873
1874 (defun ange-ftp-guess-hash-mark-size (proc)
1875   (if ange-ftp-send-hash
1876       (save-excursion
1877         (set-buffer (process-buffer proc))
1878         (let* ((status (ange-ftp-raw-send-cmd proc "hash"))
1879                (result (car status))
1880                (line (cdr status)))
1881           (ange-ftp-save-match-data
1882             (if (string-match ange-ftp-hash-mark-msgs line)
1883                 (let ((size (string-to-int
1884                             (substring line
1885                                        (match-beginning 1)
1886                                        (match-end 1)))))
1887                   (setq ange-ftp-ascii-hash-mark-size size
1888                         ange-ftp-hash-mark-unit (ash size -4))
1889
1890                   ;; if a default value for this is set, use that value.
1891                   (or ange-ftp-binary-hash-mark-size
1892                       (setq ange-ftp-binary-hash-mark-size size)))))))))
1893
1894 (defun ange-ftp-get-process (host user)
1895   "Return an FTP subprocess connected to HOST and logged in as USER.
1896 Create a new process if needed."
1897   (let* ((name (ange-ftp-ftp-process-buffer host user))
1898          (proc (get-process name)))
1899     (if (and proc (memq (process-status proc) '(run open)))
1900         proc
1901       (let ((pass (ange-ftp-quote-string
1902                    (ange-ftp-get-passwd host user)))
1903             (account (ange-ftp-quote-string
1904                       (ange-ftp-get-account host user))))
1905         ;; grab a suitable process.
1906         (setq proc (ange-ftp-start-process host user name))
1907
1908         ;; login to FTP server.
1909         (if (ange-ftp-use-smart-gateway-p host)
1910             (ange-ftp-smart-login host user pass account proc)
1911           (ange-ftp-normal-login host user pass account proc))
1912
1913         ;; Tell client to send back hash-marks as progress.  It isn't usually
1914         ;; fatal if this command fails.
1915         (ange-ftp-guess-hash-mark-size proc)
1916
1917         ;; Guess at the host type.
1918         (ange-ftp-guess-host-type host user)
1919
1920         ;; Run any user-specified hooks.  Note that proc, host and user are
1921         ;; dynamically bound at this point.
1922         (run-hooks 'ange-ftp-process-startup-hook))
1923       proc)))
1924
1925 ;; Variables for caching host and host-type
1926 (defvar ange-ftp-host-cache nil)
1927 (defvar ange-ftp-host-type-cache nil)
1928
1929 ;; If ange-ftp-host-type is called with the optional user
1930 ;; argument, it will attempt to guess the host type by connecting
1931 ;; as user, if necessary. For efficiency, I have tried to give this
1932 ;; optional second argument only when necessary. Have I missed any calls
1933 ;; to ange-ftp-host-type where it should have been supplied?
1934
1935 (defun ange-ftp-host-type (host &optional user)
1936   "Return a symbol which represents the type of the HOST given.
1937 If the optional argument USER is given, attempts to guess the
1938 host-type by logging in as USER."
1939   (if (eq host ange-ftp-host-cache)
1940       ange-ftp-host-type-cache
1941     ;; Trigger an ftp connection, in case we need to guess at the host type.
1942     (if (and user (ange-ftp-get-process host user) (eq host ange-ftp-host-cache))
1943         ange-ftp-host-type-cache
1944       (setq ange-ftp-host-cache host
1945             ange-ftp-host-type-cache
1946             (cond ((ange-ftp-dumb-unix-host host)
1947                    'dumb-unix)
1948 ;;                ((and (fboundp 'ange-ftp-vos-host)
1949 ;;                      (ange-ftp-vos-host host))
1950 ;;                 'vos)
1951                   ((and (fboundp 'ange-ftp-vms-host)
1952                         (ange-ftp-vms-host host))
1953                    'vms)
1954                   ((and (fboundp 'ange-ftp-mts-host)
1955                         (ange-ftp-mts-host host))
1956                    'mts)
1957                   ((and (fboundp 'ange-ftp-cms-host)
1958                         (ange-ftp-cms-host host))
1959                    'cms)
1960                   (t
1961                    'unix))))))
1962
1963 ;; It would be nice to abstract the functions ange-ftp-TYPE-host and
1964 ;; ange-ftp-add-TYPE-host. The trick is to abstract these functions
1965 ;; without sacrificing speed. Also, having separate variables
1966 ;; ange-ftp-TYPE-regexp is more user friendly then requiring the user to
1967 ;; set an alist to indicate that a host is of a given type. Even with
1968 ;; automatic host type recognition, setting a regexp is still a good idea
1969 ;; (for efficiency) if you log into a particular non-UNIX host frequently.
1970
1971 (defvar ange-ftp-fix-name-func-alist nil
1972   "Alist saying how to convert file name to the host's syntax.
1973 Association list of \( TYPE \. FUNC \) pairs, where FUNC is a routine
1974 which can change a UNIX file name into a name more suitable for a host of type
1975 TYPE.")
1976
1977 (defvar ange-ftp-fix-dir-name-func-alist nil
1978   "Alist saying how to convert directory name to the host's syntax.
1979 Association list of \( TYPE \. FUNC \) pairs, where FUNC is a routine
1980 which can change UNIX directory name into a directory name more suitable
1981 for a host of type TYPE.")
1982
1983 ;; *** Perhaps the sense of this variable should be inverted, since there
1984 ;; *** is only 1 host type that can take ls-style listing options.
1985 (defvar ange-ftp-dumb-host-types '(dumb-unix)
1986   "List of host types that can't take UNIX ls-style listing options.")
1987
1988 (defun ange-ftp-send-cmd (host user cmd &optional msg cont nowait)
1989   "Find an ftp process connected to HOST logged in as USER and send it CMD.
1990 MSG is an optional status message to be output before and after issuing the
1991 command.
1992 See the documentation for ange-ftp-raw-send-cmd for a description of CONT
1993 and NOWAIT."
1994   ;; Handle conversion to remote file name syntax and remote ls option
1995   ;; capability.
1996   (let ((cmd0 (car cmd))
1997         (cmd1 (nth 1 cmd))
1998         (ange-ftp-this-user user)
1999         (ange-ftp-this-host host)
2000         (ange-ftp-this-msg msg)
2001         cmd2 cmd3 host-type fix-name-func)
2002
2003     (cond
2004
2005      ;; pwd case (We don't care what host-type.)
2006      ((null cmd1))
2007
2008      ;; cmd == 'dir "remote-name" "local-name" "ls-switches"
2009      ((progn
2010        (setq cmd2 (nth 2 cmd)
2011              host-type (ange-ftp-host-type host user))
2012        ;; This will trigger an FTP login, if one doesn't exist
2013        (eq cmd0 'dir))
2014       (setq cmd1 (funcall
2015                   (or (cdr (assq host-type ange-ftp-fix-dir-name-func-alist))
2016                       'identity)
2017                   cmd1)
2018             cmd3 (nth 3 cmd))
2019       ;; Need to deal with the HP-UX ftp bug. This should also allow
2020       ;; us to resolve symlinks to directories on SysV machines. (Sebastian will
2021       ;; be happy.)
2022       (and (eq host-type 'unix)
2023            (string-match "/$" cmd1)
2024            (not (string-match "R" cmd3))
2025            (setq cmd1 (concat cmd1 ".")))
2026       ;; If the remote ls can take switches, put them in
2027       (or (memq host-type ange-ftp-dumb-host-types)
2028           (setq cmd0 'ls
2029                 cmd1 (format "\"%s %s\"" cmd3 cmd1))))
2030
2031      ;; First argument is the remote name
2032      ((progn
2033         (setq fix-name-func (or (cdr (assq host-type
2034                                            ange-ftp-fix-name-func-alist))
2035                                 'identity))
2036         (memq cmd0 '(get delete mkdir rmdir cd)))
2037       (setq cmd1 (funcall fix-name-func cmd1)))
2038
2039      ;; Second argument is the remote name
2040      ((memq cmd0 '(append put chmod))
2041       (setq cmd2 (funcall fix-name-func cmd2)))
2042
2043      ;; Both arguments are remote names
2044      ((eq cmd0 'rename)
2045       (setq cmd1 (funcall fix-name-func cmd1)
2046             cmd2 (funcall fix-name-func cmd2))))
2047
2048     ;; Turn the command into one long string
2049     (setq cmd0 (symbol-name cmd0))
2050     (setq cmd (concat cmd0
2051                       (and cmd1 (concat " " cmd1))
2052                       (and cmd2 (concat " " cmd2))))
2053
2054     ;; Actually send the resulting command.
2055     (let (afsc-result
2056           afsc-line)
2057       (ange-ftp-raw-send-cmd
2058        (ange-ftp-get-process host user)
2059        cmd
2060        msg
2061        (list
2062         (function (lambda (result line host user
2063                                   cmd msg cont nowait)
2064                     (or cont
2065                         (setq afsc-result result
2066                               afsc-line line))
2067                     (if result
2068                         (ange-ftp-call-cont cont result line)
2069                       (ange-ftp-raw-send-cmd
2070                        (ange-ftp-get-process host user)
2071                        cmd
2072                        msg
2073                        (list
2074                         (function (lambda (result line cont)
2075                                     (or cont
2076                                         (setq afsc-result result
2077                                               afsc-line line))
2078                                     (ange-ftp-call-cont cont result line)))
2079                         cont)
2080                        nowait))))
2081         host user cmd msg cont nowait)
2082        nowait)
2083
2084       (if nowait
2085           nil
2086         (if cont
2087             nil
2088           (cons afsc-result afsc-line))))))
2089
2090 ;; It might be nice to message users about the host type identified,
2091 ;; but there is so much other messaging going on, it would not be
2092 ;; seen. No point in slowing things down just so users can read
2093 ;; a host type message.
2094
2095 (defconst ange-ftp-cms-name-template
2096   (concat
2097    "^[-A-Z0-9$*][-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?"
2098    "[-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?\\.[0-9][0-9][0-9A-Z]$"))
2099 (defconst ange-ftp-vms-name-template
2100   "^[-A-Z0-9_$]+:\\[[-A-Z0-9_$]+\\(\\.[-A-Z0-9_$]+\\)*\\]$")
2101 (defconst ange-ftp-mts-name-template
2102   "^[A-Z0-9._][A-Z0-9._][A-Z0-9._][A-Z0-9._]:$")
2103
2104 (defun ange-ftp-guess-host-type (host user)
2105   "Guess at the the host type of HOST.
2106 Works by doing a pwd and examining the directory syntax."
2107   (let ((host-type (ange-ftp-host-type host))
2108         (key (concat host "/" user "/~")))
2109     (if (eq host-type 'unix)
2110         ;; Note that ange-ftp-host-type returns unix as the default value.
2111         (ange-ftp-save-match-data
2112           (let* ((result (ange-ftp-get-pwd host user))
2113                  (dir (car result))
2114                  fix-name-func)
2115             (cond ((null dir)
2116                    (message "Warning! Unable to get home directory")
2117                    (sit-for 1)
2118                    (if (string-match
2119                         "^450 No current working directory defined$"
2120                         (cdr result))
2121
2122                        ;; We'll assume that if pwd bombs with this
2123                        ;; error message, then it's CMS.
2124                        (progn
2125                          (ange-ftp-add-cms-host host)
2126                          (setq ange-ftp-host-cache host
2127                                ange-ftp-host-type-cache 'cms))))
2128
2129                   ;; try for VMS
2130                   ((string-match ange-ftp-vms-name-template dir)
2131                    (ange-ftp-add-vms-host host)
2132                    ;; The add-host functions clear the host type cache.
2133                    ;; Therefore, need to set the cache afterwards.
2134                    (setq ange-ftp-host-cache host
2135                          ange-ftp-host-type-cache 'vms))
2136
2137                   ;; try for MTS
2138                   ((string-match ange-ftp-mts-name-template dir)
2139                    (ange-ftp-add-mts-host host)
2140                    (setq ange-ftp-host-cache host
2141                          ange-ftp-host-type-cache 'mts))
2142
2143                   ;; try for CMS
2144                   ((string-match ange-ftp-cms-name-template dir)
2145                    (ange-ftp-add-cms-host host)
2146                    (setq ange-ftp-host-cache host
2147                          ange-ftp-host-type-cache 'cms))
2148
2149                   ;; assume UN*X
2150                   (t
2151                    (setq ange-ftp-host-cache host
2152                          ange-ftp-host-type-cache 'unix)))
2153
2154             ;; Now that we have done a pwd, might as well put it in
2155             ;; the expand-dir hashtable.
2156             (let ((ange-ftp-this-user user)
2157                   (ange-ftp-this-host host))
2158               (setq fix-name-func (cdr (assq ange-ftp-host-type-cache
2159                                              ange-ftp-fix-name-func-alist)))
2160               (if fix-name-func
2161                   (setq dir (funcall fix-name-func dir 'reverse))))
2162             (ange-ftp-put-hash-entry key dir
2163                                      ange-ftp-expand-dir-hashtable))))
2164
2165     ;; In the special case of CMS make sure that know the
2166     ;; expansion of the home minidisk now, because we will
2167     ;; be doing a lot of cd's.
2168     (if (and (eq host-type 'cms)
2169              (not (ange-ftp-hash-entry-exists-p
2170                    key ange-ftp-expand-dir-hashtable)))
2171         (let ((dir (car (ange-ftp-get-pwd host user))))
2172           (if dir
2173               (ange-ftp-put-hash-entry key (concat "/" dir)
2174                                        ange-ftp-expand-dir-hashtable)
2175             (message "Warning! Unable to get home directory")
2176             (sit-for 1))))))
2177
2178 \f
2179 ;;;; ------------------------------------------------------------
2180 ;;;; Remote file and directory listing support.
2181 ;;;; ------------------------------------------------------------
2182
2183 ;; Returns whether HOST's FTP server doesn't like \'ls\' or \'dir\' commands
2184 ;; to take switch arguments.
2185 (defun ange-ftp-dumb-unix-host (host)
2186   (and ange-ftp-dumb-unix-host-regexp
2187        (ange-ftp-save-match-data
2188          (string-match ange-ftp-dumb-unix-host-regexp host))))
2189
2190 (defun ange-ftp-add-dumb-unix-host (host)
2191   "Interactively adds a given HOST to ange-ftp-dumb-unix-host-regexp."
2192   (interactive
2193    (list (read-string "Host: "
2194                       (let ((name (or (buffer-file-name) default-directory)))
2195                         (and name (car (ange-ftp-ftp-name name)))))))
2196   (if (not (ange-ftp-dumb-unix-host host))
2197       (setq ange-ftp-dumb-unix-host-regexp
2198             (concat "^" (regexp-quote host) "$"
2199                     (and ange-ftp-dumb-unix-host-regexp "\\|")
2200                     ange-ftp-dumb-unix-host-regexp)
2201             ange-ftp-host-cache nil)))
2202
2203 (defvar ange-ftp-parse-list-func-alist nil
2204   "Alist saying how to parse directory listings for certain OS types.
2205 Association list of \( TYPE \. FUNC \) pairs.  The FUNC is a routine
2206 which can parse the output from a DIR listing for a host of type TYPE.")
2207
2208 ;; With no-error nil, this function returns:
2209 ;; an error if file is not an ange-ftp-name
2210 ;;                      (This should never happen.)
2211 ;; an error if either the listing is unreadable or there is an ftp error.
2212 ;; the listing (a string), if everything works.
2213 ;;
2214 ;; With no-error t, it returns:
2215 ;; an error if not an ange-ftp-name
2216 ;; error if listing is unreable (most likely caused by a slow connection)
2217 ;; nil if ftp error (this is because although asking to list a nonexistent
2218 ;;                   directory on a remote unix machine usually (except
2219 ;;                   maybe for dumb hosts) returns an ls error, but no
2220 ;;                   ftp error, if the same is done on a VMS machine,
2221 ;;                   an ftp error is returned. Need to trap the error
2222 ;;                   so we can go on and try to list the parent.)
2223 ;; the listing, if everything works.
2224
2225 ;; If WILDCARD is non-nil, then this implements the guts of insert-directory
2226 ;; in the wildcard case.  Then we make a relative directory listing
2227 ;; of FILE within the directory specified by `default-directory'.
2228
2229 (defun ange-ftp-ls (file lsargs parse &optional no-error wildcard)
2230   "Return the output of an `DIR' or `ls' command done over ftp.
2231 FILE is the full name of the remote file, LSARGS is any args to pass to the
2232 `ls' command, and PARSE specifies that the output should be parsed and stored
2233 away in the internal cache."
2234   ;; If parse is t, we assume that file is a directory. i.e. we only parse
2235   ;; full directory listings.
2236   (let* ((ange-ftp-this-file (ange-ftp-expand-file-name file))
2237          (parsed (ange-ftp-ftp-name ange-ftp-this-file)))
2238     (if parsed
2239         (let* ((host (nth 0 parsed))
2240                (user (nth 1 parsed))
2241                (name (ange-ftp-quote-string (nth 2 parsed)))
2242                (key (directory-file-name ange-ftp-this-file))
2243                (host-type (ange-ftp-host-type host user))
2244                (dumb (memq host-type ange-ftp-dumb-host-types))
2245                result
2246                temp
2247                lscmd parse-func)
2248           (if (string-equal name "")
2249               (setq name
2250                     (ange-ftp-real-file-name-as-directory
2251                           (ange-ftp-expand-dir host user "~"))))
2252           (if (and ange-ftp-ls-cache-file
2253                    (string-equal key ange-ftp-ls-cache-file)
2254                    ;; Don't care about lsargs for dumb hosts.
2255                    (or dumb (string-equal lsargs ange-ftp-ls-cache-lsargs)))
2256               ange-ftp-ls-cache-res
2257             (setq temp (ange-ftp-make-tmp-name host))
2258             (if wildcard
2259                 (progn
2260                   (ange-ftp-cd host user (file-name-directory name))
2261                   (setq lscmd (list 'dir file temp lsargs)))
2262               (setq lscmd (list 'dir name temp lsargs)))
2263             (unwind-protect
2264                 (if (car (setq result (ange-ftp-send-cmd
2265                                        host
2266                                        user
2267                                        lscmd
2268                                        (format "Listing %s"
2269                                                (ange-ftp-abbreviate-filename
2270                                                 ange-ftp-this-file)))))
2271                     (save-excursion
2272                       (set-buffer (get-buffer-create
2273                                    ange-ftp-data-buffer-name))
2274                       (erase-buffer)
2275                       (if (ange-ftp-real-file-readable-p temp)
2276                           (ange-ftp-real-insert-file-contents temp)
2277                         (sleep-for ange-ftp-retry-time)
2278                                         ;wait for file to possibly appear
2279                         (if (ange-ftp-real-file-readable-p temp)
2280                             ;; Try again.
2281                             (ange-ftp-real-insert-file-contents temp)
2282                           (ange-ftp-error host user
2283                                           (format
2284                                            "list data file %s not readable"
2285                                            temp))))
2286                       (if parse
2287                           (ange-ftp-set-files
2288                            ange-ftp-this-file
2289                            (if (setq
2290                                 parse-func
2291                                 (cdr (assq host-type
2292                                            ange-ftp-parse-list-func-alist)))
2293                                (funcall parse-func)
2294                              (ange-ftp-parse-dired-listing lsargs))))
2295                       (setq ange-ftp-ls-cache-file key
2296                             ange-ftp-ls-cache-lsargs lsargs
2297                                         ; For dumb hosts-types this is
2298                                         ; meaningless but harmless.
2299                             ange-ftp-ls-cache-res (buffer-string))
2300                       ;; (kill-buffer (current-buffer))
2301                       ange-ftp-ls-cache-res)
2302                   (if no-error
2303                       nil
2304                     (ange-ftp-error host user
2305                                     (concat "DIR failed: " (cdr result)))))
2306               (ange-ftp-del-tmp-name temp))))
2307       (error "Should never happen. Please report. Bug ref. no.: 1"))))
2308 \f
2309 ;;;; ------------------------------------------------------------
2310 ;;;; Directory information caching support.
2311 ;;;; ------------------------------------------------------------
2312
2313 (defconst ange-ftp-date-regexp
2314   (concat
2315    " \\(Jan\\|Feb\\|Mar\\|Apr\\|May\\|Jun\\|Jul\\|Aug\\|Sep\\|Oct"
2316    "\\|Nov\\|Dec\\) +[0-3]?[0-9] "))
2317
2318 (defvar ange-ftp-add-file-entry-alist nil
2319   "Alist saying how to add file entries on certain OS types.
2320 Association list of pairs \( TYPE \. FUNC \), where FUNC
2321 is a function to be used to add a file entry for the OS TYPE. The
2322 main reason for this alist is to deal with file versions in VMS.")
2323
2324 (defvar ange-ftp-delete-file-entry-alist nil
2325   "Alist saying how to delete files on certain OS types.
2326 Association list of pairs \( TYPE \. FUNC \), where FUNC
2327 is a function to be used to delete a file entry for the OS TYPE.
2328 The main reason for this alist is to deal with file versions in VMS.")
2329
2330 (defun ange-ftp-add-file-entry (name &optional dir-p)
2331   "Add a file entry for file NAME, if its directory info exists."
2332   (funcall (or (cdr (assq (ange-ftp-host-type
2333                            (car (ange-ftp-ftp-name name)))
2334                           ange-ftp-add-file-entry-alist))
2335                'ange-ftp-internal-add-file-entry)
2336            name dir-p)
2337   (setq ange-ftp-ls-cache-file nil))
2338
2339 (defun ange-ftp-delete-file-entry (name &optional dir-p)
2340   "Delete the file entry for file NAME, if its directory info exists."
2341   (funcall (or (cdr (assq (ange-ftp-host-type
2342                            (car (ange-ftp-ftp-name name)))
2343                           ange-ftp-delete-file-entry-alist))
2344                'ange-ftp-internal-delete-file-entry)
2345            name dir-p)
2346   (setq ange-ftp-ls-cache-file nil))
2347
2348 (defmacro ange-ftp-parse-filename ()
2349   ;;Extract the filename from the current line of a dired-like listing.
2350   (` (let ((eol (progn (end-of-line) (point))))
2351        (beginning-of-line)
2352        (if (re-search-forward ange-ftp-date-regexp eol t)
2353            (progn
2354              (skip-chars-forward " ")
2355              (skip-chars-forward "^ " eol)
2356              (skip-chars-forward " " eol)
2357              ;; We bomb on filenames starting with a space.
2358              (buffer-substring (point) eol))))))
2359
2360 ;; This deals with the F switch. Should also do something about
2361 ;; unquoting names obtained with the SysV b switch and the GNU Q
2362 ;; switch. See Sebastian's dired-get-filename.
2363
2364 (defmacro ange-ftp-ls-parser ()
2365   ;; Note that switches is dynamically bound.
2366   ;; Meant to be called by ange-ftp-parse-dired-listing
2367   (` (let ((tbl (ange-ftp-make-hashtable))
2368            (used-F (and (stringp switches)
2369                         (string-match "F" switches)))
2370            file-type symlink directory file)
2371        (while (setq file (ange-ftp-parse-filename))
2372          (beginning-of-line)
2373          (skip-chars-forward "\t 0-9")
2374          (setq file-type (following-char)
2375                directory (eq file-type ?d))
2376          (if (eq file-type ?l)
2377              (if (string-match " -> " file)
2378                  (setq symlink (substring file (match-end 0))
2379                        file (substring file 0 (match-beginning 0)))
2380                ;; Shouldn't happen
2381                (setq symlink ""))
2382            (setq symlink nil))
2383          ;; Only do a costly regexp search if the F switch was used.
2384          (if (and used-F
2385                   (not (string-equal file ""))
2386                   (looking-at
2387                    ".[-r][-w]\\([^ ]\\)[-r][-w]\\([^ ]\\)[-r][-w]\\([^ ]\\)"))
2388              (let ((socket (eq file-type ?s))
2389                    (executable
2390                     (and (not symlink) ; x bits don't mean a thing for symlinks
2391                          (string-match "[xst]"
2392                                        (concat
2393                                         (buffer-substring
2394                                          (match-beginning 1)
2395                                          (match-end 1))
2396                                         (buffer-substring
2397                                          (match-beginning 2)
2398                                          (match-end 2))
2399                                         (buffer-substring
2400                                          (match-beginning 3)
2401                                          (match-end 3)))))))
2402                ;; Some ls's with the F switch mark symlinks with an @ (ULTRIX)
2403                ;; and others don't. (sigh...) Beware, that some Unix's don't
2404                ;; seem to believe in the F-switch
2405                (if (or (and symlink (string-match "@$" file))
2406                        (and directory (string-match "/$" file))
2407                        (and executable (string-match "*$" file))
2408                        (and socket (string-match "=$" file)))
2409                    (setq file (substring file 0 -1)))))
2410          (ange-ftp-put-hash-entry file (or symlink directory) tbl)
2411          (forward-line 1))
2412        (ange-ftp-put-hash-entry "." t tbl)
2413        (ange-ftp-put-hash-entry ".." t tbl)
2414        tbl)))
2415
2416 ;;; The dl stuff for descriptive listings
2417
2418 (defvar ange-ftp-dl-dir-regexp nil
2419   "Regexp matching directories which are listed in dl format.
2420 This regexp should not be anchored with a trailing `$', because it should
2421 match subdirectories as well.")
2422
2423 (defun ange-ftp-add-dl-dir (dir)
2424   "Interactively adds a DIR to ange-ftp-dl-dir-regexp."
2425   (interactive
2426    (list (read-string "Directory: "
2427                       (let ((name (or (buffer-file-name) default-directory)))
2428                         (and name (ange-ftp-ftp-name name)
2429                              (file-name-directory name))))))
2430   (if (not (and ange-ftp-dl-dir-regexp
2431                 (string-match ange-ftp-dl-dir-regexp dir)))
2432       (setq ange-ftp-dl-dir-regexp
2433             (concat "^" (regexp-quote dir)
2434                     (and ange-ftp-dl-dir-regexp "\\|")
2435                     ange-ftp-dl-dir-regexp))))
2436
2437 (defmacro ange-ftp-dl-parser ()
2438   ;; Parse the current buffer, which is assumed to be a descriptive
2439   ;; listing, and return a hashtable.
2440   (` (let ((tbl (ange-ftp-make-hashtable)))
2441        (while (not (eobp))
2442          (ange-ftp-put-hash-entry
2443           (buffer-substring (point)
2444                             (progn
2445                               (skip-chars-forward "^ /\n")
2446                               (point)))
2447           (eq (following-char) ?/)
2448           tbl)
2449          (forward-line 1))
2450        (ange-ftp-put-hash-entry "." t tbl)
2451        (ange-ftp-put-hash-entry ".." t tbl)
2452        tbl)))
2453
2454 ;; Parse the current buffer which is assumed to be in a dired-like listing
2455 ;; format, and return a hashtable as the result. If the listing is not really
2456 ;; a listing, then return nil.
2457
2458 (defun ange-ftp-parse-dired-listing (&optional switches)
2459   (ange-ftp-save-match-data
2460     (cond
2461      ((looking-at "^total [0-9]+$")
2462       (forward-line 1)
2463       ;; Some systems put in a blank line here.
2464       (if (eolp) (forward-line 1))
2465       (ange-ftp-ls-parser))
2466      ((looking-at "[^\n]+\\( not found\\|: Not a directory\\)\n\\'")
2467       ;; It's an ls error message.
2468       nil)
2469      ((eobp) ; i.e. (zerop (buffer-size))
2470       ;; This could be one of:
2471       ;; (1) An Ultrix ls error message
2472       ;; (2) A listing with the A switch of an empty directory
2473       ;;     on a machine which doesn't give a total line.
2474       ;; (3) The twilight zone.
2475       ;; We'll assume (1) for now.
2476       nil)
2477      ((re-search-forward ange-ftp-date-regexp nil t)
2478       (beginning-of-line)
2479       (ange-ftp-ls-parser))
2480      ((re-search-forward "^[^ \n\t]+ +\\([0-9]+\\|-\\|=\\) " nil t)
2481       ;; It's a dl listing (I hope).
2482       ;; file is bound by the call to ange-ftp-ls
2483       (ange-ftp-add-dl-dir ange-ftp-this-file)
2484       (beginning-of-line)
2485       (ange-ftp-dl-parser))
2486      (t nil))))
2487
2488 (defun ange-ftp-set-files (directory files)
2489   "For a given DIRECTORY, set or change the associated FILES hashtable."
2490   (and files (ange-ftp-put-hash-entry (file-name-as-directory directory)
2491                                       files ange-ftp-files-hashtable)))
2492
2493 (defun ange-ftp-get-files (directory &optional no-error)
2494   "Given a given DIRECTORY, return a hashtable of file entries.
2495 This will give an error or return nil, depending on the value of
2496 NO-ERROR, if a listing for DIRECTORY cannot be obtained."
2497   (setq directory (file-name-as-directory directory)) ;normalize
2498   (or (ange-ftp-get-hash-entry directory ange-ftp-files-hashtable)
2499       (ange-ftp-save-match-data
2500         (and (ange-ftp-ls directory
2501                           ;; This is an efficiency hack. We try to
2502                           ;; anticipate what sort of listing dired
2503                           ;; might want, and cache just such a listing.
2504                           (if (and (boundp 'dired-actual-switches)
2505                                    (stringp dired-actual-switches)
2506                                    ;; We allow the A switch, which lists
2507                                    ;; all files except "." and "..".
2508                                    ;; This is OK because we manually
2509                                    ;; insert these entries
2510                                    ;; in the hash table.
2511                                    (string-match
2512                                     "[aA]" dired-actual-switches)
2513                                    (string-match
2514                                     "l" dired-actual-switches)
2515                                    (not (string-match
2516                                          "R" dired-actual-switches)))
2517                               dired-actual-switches
2518                             (if (and (boundp 'dired-listing-switches)
2519                                      (stringp dired-listing-switches)
2520                                      (string-match
2521                                       "[aA]" dired-listing-switches)
2522                                      (string-match
2523                                       "l" dired-listing-switches)
2524                                      (not (string-match
2525                                            "R" dired-listing-switches)))
2526                                 dired-listing-switches
2527                               "-al"))
2528                           t no-error)
2529              (ange-ftp-get-hash-entry
2530               directory ange-ftp-files-hashtable)))))
2531
2532 ;; Given NAME, return the file part that can be used for looking up the
2533 ;; file's entry in a hashtable.
2534 (defmacro ange-ftp-get-file-part (name)
2535   (` (let ((file (file-name-nondirectory (, name))))
2536        (if (string-equal file "")
2537            "."
2538          file))))
2539
2540 ;; Return whether ange-ftp-file-entry-p and ange-ftp-get-file-entry are
2541 ;; allowed to determine if NAME is a sub-directory by listing it directly,
2542 ;; rather than listing its parent directory. This is used for efficiency so
2543 ;; that a wasted listing is not done:
2544 ;; 1. When looking for a .dired file in dired-x.el.
2545 ;; 2. The syntax of FILE and DIR make it impossible that FILE could be a valid
2546 ;;     subdirectory. This is of course an OS dependent judgement.
2547
2548 (defmacro ange-ftp-allow-child-lookup (dir file)
2549   (` (not
2550       (let* ((efile (, file)) ; expand once.
2551              (edir (, dir))
2552              (parsed (ange-ftp-ftp-name edir))
2553              (host-type (ange-ftp-host-type
2554                          (car parsed))))
2555         (or
2556 ;;; This variable seems not to exist in Emacs 19 -- rms.
2557 ;;;      ;; Deal with dired
2558 ;;;      (and (boundp 'dired-local-variables-file)
2559 ;;;           (stringp dired-local-variables-file)
2560 ;;;           (string-equal dired-local-variables-file efile))
2561          ;; No dots in dir names in vms.
2562          (and (eq host-type 'vms)
2563               (string-match "\\." efile))
2564          ;; No subdirs in mts of cms.
2565          (and (memq host-type '(mts cms))
2566               (not (string-equal "/" (nth 2 parsed)))))))))
2567
2568 (defun ange-ftp-file-entry-p (name)
2569   "Given NAME, return whether there is a file entry for it."
2570   (let* ((name (directory-file-name name))
2571          (dir (file-name-directory name))
2572          (ent (ange-ftp-get-hash-entry dir ange-ftp-files-hashtable))
2573          (file (ange-ftp-get-file-part name)))
2574     (if ent
2575         (ange-ftp-hash-entry-exists-p file ent)
2576       (or (and (ange-ftp-allow-child-lookup dir file)
2577                (setq ent (ange-ftp-get-files name t))
2578                ;; Try a child lookup. i.e. try to list file as a
2579                ;; subdirectory of dir. This is a good idea because
2580                ;; we may not have read permission for file's parent. Also,
2581                ;; people tend to work down directory trees anyway. We use
2582                ;; no-error ;; because if file does not exist as a subdir.,
2583                ;; then dumb hosts will give an ftp error. Smart unix hosts
2584                ;; will simply send back the ls
2585                ;; error message.
2586                (ange-ftp-get-hash-entry "." ent))
2587           ;; Child lookup failed. Try the parent. If this bombs,
2588           ;; we are at wits end -- signal an error.
2589           ;; Problem: If this signals an error, the error message
2590           ;; may  not have a lot to do with what went wrong.
2591           (ange-ftp-hash-entry-exists-p file
2592                                         (ange-ftp-get-files dir))))))
2593
2594 (defun ange-ftp-get-file-entry (name)
2595   "Given NAME, return the given file entry.
2596 The entry will be either t for a directory, nil for a normal file,
2597 or a string for a symlink. If the file isn't in the hashtable,
2598 this also returns nil."
2599   (let* ((name (directory-file-name name))
2600          (dir (file-name-directory name))
2601          (ent (ange-ftp-get-hash-entry dir ange-ftp-files-hashtable))
2602          (file (ange-ftp-get-file-part name)))
2603     (if ent
2604         (ange-ftp-get-hash-entry file ent)
2605       (or (and (ange-ftp-allow-child-lookup dir file)
2606                (setq ent (ange-ftp-get-files name t))
2607                (ange-ftp-get-hash-entry "." ent))
2608                ;; i.e. it's a directory by child lookup
2609           (ange-ftp-get-hash-entry file
2610                                    (ange-ftp-get-files dir))))))
2611
2612 (defun ange-ftp-internal-delete-file-entry (name &optional dir-p)
2613   (if dir-p
2614       (progn
2615         (setq name (file-name-as-directory name))
2616         (ange-ftp-del-hash-entry name ange-ftp-files-hashtable)
2617         (setq name (directory-file-name name))))
2618   ;; Note that file-name-as-directory followed by directory-file-name
2619   ;; serves to canonicalize directory file names to their unix form.
2620   ;; i.e. in VMS, FOO.DIR -> FOO/ -> FOO
2621   (let ((files (ange-ftp-get-hash-entry (file-name-directory name)
2622                                         ange-ftp-files-hashtable)))
2623     (if files
2624         (ange-ftp-del-hash-entry (ange-ftp-get-file-part name)
2625                                  files))))
2626
2627 (defun ange-ftp-internal-add-file-entry (name &optional dir-p)
2628   (and dir-p
2629        (setq name (directory-file-name name)))
2630   (let ((files (ange-ftp-get-hash-entry (file-name-directory name)
2631                                         ange-ftp-files-hashtable)))
2632     (if files
2633         (ange-ftp-put-hash-entry (ange-ftp-get-file-part name)
2634                                  dir-p
2635                                  files))))
2636
2637 (defun ange-ftp-wipe-file-entries (host user)
2638   "Get rid of entry for HOST, USER pair from file entry information hashtable."
2639   (let ((new-tbl (ange-ftp-make-hashtable (length ange-ftp-files-hashtable))))
2640     (ange-ftp-map-hashtable
2641      (function
2642       (lambda (key val)
2643         (let ((parsed (ange-ftp-ftp-name key)))
2644           (if parsed
2645               (let ((h (nth 0 parsed))
2646                     (u (nth 1 parsed)))
2647                 (or (and (equal host h) (equal user u))
2648                     (ange-ftp-put-hash-entry key val new-tbl)))))))
2649      ange-ftp-files-hashtable)
2650     (setq ange-ftp-files-hashtable new-tbl)))
2651 \f
2652 ;;;; ------------------------------------------------------------
2653 ;;;; File transfer mode support.
2654 ;;;; ------------------------------------------------------------
2655
2656 (defun ange-ftp-set-binary-mode (host user)
2657   "Tell the ftp process for the given HOST & USER to switch to binary mode."
2658   (let ((result (ange-ftp-send-cmd host user '(type "binary"))))
2659     (if (not (car result))
2660         (ange-ftp-error host user (concat "BINARY failed: " (cdr result)))
2661       (save-excursion
2662         (set-buffer (process-buffer (ange-ftp-get-process host user)))
2663         (setq ange-ftp-hash-mark-unit (ash ange-ftp-binary-hash-mark-size -4))))))
2664
2665 (defun ange-ftp-set-ascii-mode (host user)
2666   "Tell the ftp process for the given HOST & USER to switch to ascii mode."
2667   (let ((result (ange-ftp-send-cmd host user '(type "ascii"))))
2668     (if (not (car result))
2669         (ange-ftp-error host user (concat "ASCII failed: " (cdr result)))
2670       (save-excursion
2671         (set-buffer (process-buffer (ange-ftp-get-process host user)))
2672         (setq ange-ftp-hash-mark-unit (ash ange-ftp-ascii-hash-mark-size -4))))))
2673 \f
2674 (defun ange-ftp-cd (host user dir)
2675   (let ((result (ange-ftp-send-cmd host user (list 'cd dir) "Doing CD")))
2676     (or (car result)
2677         (ange-ftp-error host user (concat "CD failed: " (cdr result))))))
2678
2679 (defun ange-ftp-get-pwd (host user)
2680   "Attempts to get the current working directory for the given HOST/USER pair.
2681 Returns \( DIR . LINE \) where DIR is either the directory or NIL if not found,
2682 and LINE is the relevant success or fail line from the FTP-client."
2683   (let* ((result (ange-ftp-send-cmd host user '(pwd) "Getting PWD"))
2684          (line (cdr result))
2685          dir)
2686     (if (car result)
2687         (ange-ftp-save-match-data
2688           (and (or (string-match "\"\\([^\"]*\\)\"" line)
2689                    (string-match " \\([^ ]+\\) " line)) ; stone-age VMS servers!
2690                (setq dir (substring line
2691                                     (match-beginning 1)
2692                                     (match-end 1))))))
2693     (cons dir line)))
2694 \f
2695 ;;; ------------------------------------------------------------
2696 ;;; expand-file-name and friends...which currently don't work
2697 ;;; ------------------------------------------------------------
2698
2699 (defun ange-ftp-expand-dir (host user dir)
2700   "Return the result of doing a PWD in the current FTP session.
2701 Use the connection to machine HOST
2702 logged in as user USER and cd'd to directory DIR."
2703   (let* ((host-type (ange-ftp-host-type host user))
2704          ;; It is more efficient to call ange-ftp-host-type
2705          ;; before binding res, because ange-ftp-host-type sometimes
2706          ;; adds to the info in the expand-dir-hashtable.
2707          (fix-name-func
2708           (cdr (assq host-type ange-ftp-fix-name-func-alist)))
2709          (key (concat host "/" user "/" dir))
2710          (res (ange-ftp-get-hash-entry key ange-ftp-expand-dir-hashtable)))
2711     (or res
2712         (progn
2713           (or
2714            (string-equal user "anonymous")
2715            (string-equal user "ftp")
2716            (not (eq host-type 'unix))
2717            (let* ((ange-ftp-good-msgs (concat ange-ftp-expand-dir-regexp
2718                                               "\\|"
2719                                               ange-ftp-good-msgs))
2720                   (result (ange-ftp-send-cmd host user
2721                                              (list 'get dir "/dev/null")
2722                                              (format "expanding %s" dir)))
2723                   (line (cdr result)))
2724              (setq res
2725                    (if (string-match ange-ftp-expand-dir-regexp line)
2726                        (substring line
2727                                   (match-beginning 1)
2728                                   (match-end 1))))))
2729           (or res
2730               (if (string-equal dir "~")
2731                   (setq res (car (ange-ftp-get-pwd host user)))
2732                 (let ((home (ange-ftp-expand-dir host user "~")))
2733                   (unwind-protect
2734                       (and (ange-ftp-cd host user dir)
2735                            (setq res (car (ange-ftp-get-pwd host user))))
2736                     (ange-ftp-cd host user home)))))
2737           (if res
2738               (let ((ange-ftp-this-user user)
2739                     (ange-ftp-this-host host))
2740                 (if fix-name-func
2741                     (setq res (funcall fix-name-func res 'reverse)))
2742                 (ange-ftp-put-hash-entry
2743                  key res ange-ftp-expand-dir-hashtable)))
2744           res))))
2745
2746 (defun ange-ftp-canonize-filename (n)
2747   "Take a string and short-circuit //, /. and /.."
2748   (if (string-match ".+//" n)           ;don't upset Apollo users
2749       (setq n (substring n (1- (match-end 0)))))
2750   (let ((parsed (ange-ftp-ftp-name n)))
2751     (if parsed
2752         (let ((host (car parsed))
2753               (user (nth 1 parsed))
2754               (name (nth 2 parsed)))
2755
2756           ;; See if remote name is absolute.  If so then just expand it and
2757           ;; replace the name component of the overall name.
2758           (cond ((string-match "^/" name)
2759                  name)
2760
2761                 ;; Name starts with ~ or ~user.  Resolve that part of the name
2762                 ;; making it absolute then re-expand it.
2763                 ((string-match "^~[^/]*" name)
2764                  (let* ((tilda (substring name
2765                                           (match-beginning 0)
2766                                           (match-end 0)))
2767                         (rest (substring name (match-end 0)))
2768                         (dir (ange-ftp-expand-dir host user tilda)))
2769                    (if dir
2770                        (setq name (concat dir rest))
2771                      (error "User \"%s\" is not known"
2772                             (substring tilda 1)))))
2773
2774                 ;; relative name.  Tack on homedir and re-expand.
2775                 (t
2776                  (let ((dir (ange-ftp-expand-dir host user "~")))
2777                    (if dir
2778                        (setq name (concat
2779                                    (ange-ftp-real-file-name-as-directory dir)
2780                                    name))
2781                      (error "Unable to obtain CWD")))))
2782
2783           (setq name (ange-ftp-real-expand-file-name name))
2784
2785           ;; see if hit real expand-file-name bug...  this will probably annoy
2786           ;; some Apollo people.  I'll wait until they shout, however.
2787           (if (string-match "^//" name)
2788               (setq name (substring name 1)))
2789
2790           ;; Now substitute the expanded name back into the overall filename.
2791           (ange-ftp-replace-name-component n name))
2792
2793       ;; non-ange-ftp name.  Just expand normally.
2794       (if (eq (string-to-char n) ?/)
2795           (ange-ftp-real-expand-file-name n)
2796         (ange-ftp-real-expand-file-name
2797          (ange-ftp-real-file-name-nondirectory n)
2798          (ange-ftp-real-file-name-directory n))))))
2799
2800 (defun ange-ftp-expand-file-name (name &optional default)
2801   "Documented as original."
2802   (ange-ftp-save-match-data
2803     (if (eq (string-to-char name) ?/)
2804         (while (cond ((string-match ".+//" name) ;don't upset Apollo users
2805                       (setq name (substring name (1- (match-end 0)))))
2806                      ((string-match "/~" name)
2807                       (setq name (substring name (1- (match-end 0))))))))
2808     (cond ((eq (string-to-char name) ?~)
2809            (ange-ftp-real-expand-file-name name))
2810           ((eq (string-to-char name) ?/)
2811            (ange-ftp-canonize-filename name))
2812           ((zerop (length name))
2813            (ange-ftp-canonize-filename (or default default-directory)))
2814           ((ange-ftp-canonize-filename
2815             (concat (file-name-as-directory (or default default-directory))
2816                     name))))))
2817 \f
2818 ;;; These are problems--they are currently not enabled.
2819
2820 (defvar ange-ftp-file-name-as-directory-alist nil
2821   "Association list of \( TYPE \. FUNC \) pairs.
2822 FUNC converts a filename to a directory name for the operating
2823 system TYPE.")
2824
2825 (defun ange-ftp-file-name-as-directory (name)
2826   "Documented as original."
2827   (let ((parsed (ange-ftp-ftp-name name)))
2828     (if parsed
2829         (if (string-equal (nth 2 parsed) "")
2830             name
2831           (funcall (or (cdr (assq
2832                              (ange-ftp-host-type (car parsed))
2833                              ange-ftp-file-name-as-directory-alist))
2834                        'ange-ftp-real-file-name-as-directory)
2835                    name))
2836       (ange-ftp-real-file-name-as-directory name))))
2837
2838 (defun ange-ftp-file-name-directory (name)
2839   "Documented as original."
2840   (let ((parsed (ange-ftp-ftp-name name)))
2841     (if parsed
2842         (let ((filename (nth 2 parsed)))
2843           (if (ange-ftp-save-match-data
2844                 (string-match "^~[^/]*$" filename))
2845               name
2846             (ange-ftp-replace-name-component
2847              name
2848              (ange-ftp-real-file-name-directory filename))))
2849       (ange-ftp-real-file-name-directory name))))
2850
2851 (defun ange-ftp-file-name-nondirectory (name)
2852   "Documented as original."
2853   (let ((parsed (ange-ftp-ftp-name name)))
2854     (if parsed
2855         (let ((filename (nth 2 parsed)))
2856           (if (ange-ftp-save-match-data
2857                 (string-match "^~[^/]*$" filename))
2858               ""
2859             (ange-ftp-real-file-name-nondirectory name)))
2860       (ange-ftp-real-file-name-nondirectory name))))
2861
2862 (defun ange-ftp-directory-file-name (dir)
2863   "Documented as original."
2864   (let ((parsed (ange-ftp-ftp-name dir)))
2865     (if parsed
2866         (ange-ftp-replace-name-component
2867            dir
2868            (ange-ftp-real-directory-file-name (nth 2 parsed)))
2869       (ange-ftp-real-directory-file-name dir))))
2870
2871 \f
2872 ;;; Hooks that handle Emacs primitives.
2873
2874 ;; Returns non-nil if should transfer FILE in binary mode.
2875 (defun ange-ftp-binary-file (file)
2876   (ange-ftp-save-match-data
2877     (string-match ange-ftp-binary-file-name-regexp file)))
2878
2879 (defun ange-ftp-write-region (start end filename &optional append visit)
2880   (setq filename (expand-file-name filename))
2881   (let ((parsed (ange-ftp-ftp-name filename)))
2882     (if parsed
2883         (let* ((host (nth 0 parsed))
2884                (user (nth 1 parsed))
2885                (name (ange-ftp-quote-string (nth 2 parsed)))
2886                (temp (ange-ftp-make-tmp-name host))
2887                (binary (ange-ftp-binary-file filename))
2888                (cmd (if append 'append 'put))
2889                (abbr (ange-ftp-abbreviate-filename filename)))
2890           (unwind-protect
2891               (progn
2892                 (let ((executing-macro t)
2893                       (filename (buffer-file-name))
2894                       (mod-p (buffer-modified-p)))
2895                   (unwind-protect
2896                       (ange-ftp-real-write-region start end temp nil visit)
2897                     ;; cleanup forms
2898                     (setq buffer-file-name filename)
2899                     (set-buffer-modified-p mod-p)))
2900                 (if binary
2901                     (ange-ftp-set-binary-mode host user))
2902
2903                 ;; tell the process filter what size the transfer will be.
2904                 (let ((attr (file-attributes temp)))
2905                   (if attr
2906                       (ange-ftp-set-xfer-size host user (nth 7 attr))))
2907
2908                 ;; put or append the file.
2909                 (let ((result (ange-ftp-send-cmd host user
2910                                                  (list cmd temp name)
2911                                                  (format "Writing %s" abbr))))
2912                   (or (car result)
2913                       (signal 'ftp-error
2914                               (list
2915                                "Opening output file"
2916                                (format "FTP Error: \"%s\"" (cdr result))
2917                                filename)))))
2918             (ange-ftp-del-tmp-name temp)
2919             (if binary
2920                 (ange-ftp-set-ascii-mode host user)))
2921           (if (eq visit t)
2922               (progn
2923                 (set-visited-file-modtime '(0 0))
2924                 (ange-ftp-set-buffer-mode)
2925                 (setq buffer-file-name filename)
2926                 (set-buffer-modified-p nil)))
2927           (ange-ftp-message "Wrote %s" abbr)
2928           (ange-ftp-add-file-entry filename))
2929       (ange-ftp-real-write-region start end filename append visit))))
2930
2931 (defun ange-ftp-insert-file-contents (filename &optional visit beg end replace)
2932   (barf-if-buffer-read-only)
2933   (setq filename (expand-file-name filename))
2934   (let ((parsed (ange-ftp-ftp-name filename)))
2935     (if parsed
2936         (progn
2937           (if visit
2938               (setq buffer-file-name filename))
2939           (if (or (file-exists-p filename)
2940                   (progn
2941                     (setq ange-ftp-ls-cache-file nil)
2942                     (ange-ftp-del-hash-entry (file-name-directory filename)
2943                                              ange-ftp-files-hashtable)
2944                     (file-exists-p filename)))
2945               (let* ((host (nth 0 parsed))
2946                      (user (nth 1 parsed))
2947                      (name (ange-ftp-quote-string (nth 2 parsed)))
2948                      (temp (ange-ftp-make-tmp-name host))
2949                      (binary (ange-ftp-binary-file filename))
2950                      (abbr (ange-ftp-abbreviate-filename filename))
2951                      size)
2952                 (unwind-protect
2953                     (progn
2954                       (if binary
2955                           (ange-ftp-set-binary-mode host user))
2956                       (let ((result (ange-ftp-send-cmd host user
2957                                               (list 'get name temp)
2958                                               (format "Retrieving %s" abbr))))
2959                         (or (car result)
2960                             (signal 'ftp-error
2961                                     (list
2962                                      "Opening input file"
2963                                      (format "FTP Error: \"%s\"" (cdr result))
2964                                      filename))))
2965                       (if (or (ange-ftp-real-file-readable-p temp)
2966                               (sleep-for ange-ftp-retry-time)
2967                               ;; Wait for file to hopefully appear.
2968                               (ange-ftp-real-file-readable-p temp))
2969                           (setq
2970                            size
2971                            (nth 1 (ange-ftp-real-insert-file-contents
2972                                    temp visit beg end replace)))
2973                         (signal 'ftp-error
2974                                 (list
2975                                  "Opening input file:"
2976                                  (format
2977                                   "FTP Error: %s not arrived or readable"
2978                                   filename)))))
2979                   (if binary
2980                       (ange-ftp-set-ascii-mode host user))
2981                   (ange-ftp-del-tmp-name temp))
2982                 (if visit
2983                     (progn
2984                       (set-visited-file-modtime '(0 0))
2985                       (setq buffer-file-name filename)))
2986                 (list filename size))
2987             (signal 'file-error
2988                     (list
2989                      "Opening input file"
2990                      filename))))
2991       (ange-ftp-real-insert-file-contents filename visit beg end replace))))
2992
2993 (defun ange-ftp-expand-symlink (file dir)
2994   (if (file-name-absolute-p file)
2995       (ange-ftp-replace-name-component dir file)
2996     (expand-file-name file dir)))
2997
2998 (defun ange-ftp-file-symlink-p (file)
2999   ;; call ange-ftp-expand-file-name rather than the normal
3000   ;; expand-file-name to stop loops when using a package that
3001   ;; redefines both file-symlink-p and expand-file-name.
3002   (setq file (ange-ftp-expand-file-name file))
3003   (if (ange-ftp-ftp-name file)
3004       (let ((file-ent
3005              (ange-ftp-get-hash-entry
3006               (ange-ftp-get-file-part file)
3007               (ange-ftp-get-files (file-name-directory file)))))
3008         (if (stringp file-ent)
3009             (if (file-name-absolute-p file-ent)
3010                 (ange-ftp-replace-name-component
3011                       (file-name-directory file) file-ent)
3012               file-ent)))
3013     (ange-ftp-real-file-symlink-p file)))
3014
3015 (defun ange-ftp-file-exists-p (name)
3016   (setq name (expand-file-name name))
3017   (if (ange-ftp-ftp-name name)
3018       (if (ange-ftp-file-entry-p name)
3019           (let ((file-ent (ange-ftp-get-file-entry name)))
3020             (if (stringp file-ent)
3021                 (file-exists-p
3022                  (ange-ftp-expand-symlink file-ent
3023                                           (file-name-directory
3024                                            (directory-file-name name))))
3025               t)))
3026     (ange-ftp-real-file-exists-p name)))
3027
3028 (defun ange-ftp-file-directory-p (name)
3029   (setq name (expand-file-name name))
3030   (if (ange-ftp-ftp-name name)
3031       ;; We do a file-name-as-directory on name here because some
3032       ;; machines (VMS) use a .DIR to indicate the filename associated
3033       ;; with a directory. This needs to be canonicalized.
3034       (let ((file-ent (ange-ftp-get-file-entry
3035                        (ange-ftp-file-name-as-directory name))))
3036         (if (stringp file-ent)
3037             (file-directory-p
3038              (ange-ftp-expand-symlink file-ent
3039                                       (file-name-directory
3040                                        (directory-file-name name))))
3041           file-ent))
3042     (ange-ftp-real-file-directory-p name)))
3043
3044 (defun ange-ftp-directory-files (directory &optional full match
3045                                            &rest v19-args)
3046   (setq directory (expand-file-name directory))
3047   (if (ange-ftp-ftp-name directory)
3048       (progn
3049         (ange-ftp-barf-if-not-directory directory)
3050         (let ((tail (ange-ftp-hash-table-keys
3051                      (ange-ftp-get-files directory)))
3052               files f)
3053           (setq directory (file-name-as-directory directory))
3054           (ange-ftp-save-match-data
3055             (while tail
3056               (setq f (car tail)
3057                     tail (cdr tail))
3058               (if (or (not match) (string-match match f))
3059                   (setq files
3060                         (cons (if full (concat directory f) f) files)))))
3061           (nreverse files)))
3062     (apply 'ange-ftp-real-directory-files directory full match v19-args)))
3063
3064 (defun ange-ftp-file-attributes (file)
3065   (setq file (expand-file-name file))
3066   (let ((parsed (ange-ftp-ftp-name file)))
3067     (if parsed
3068         (let ((part (ange-ftp-get-file-part file))
3069               (files (ange-ftp-get-files (file-name-directory file))))
3070           (if (ange-ftp-hash-entry-exists-p part files)
3071               (let ((host (nth 0 parsed))
3072                     (user (nth 1 parsed))
3073                     (name (nth 2 parsed))
3074                     (dirp (ange-ftp-get-hash-entry part files)))
3075                 (list (if (and (stringp dirp) (file-name-absolute-p dirp))
3076                           (ange-ftp-expand-symlink dirp
3077                                                    (file-name-directory file))
3078                         dirp)           ;0 file type
3079                       -1                ;1 link count
3080                       -1                ;2 uid
3081                       -1                ;3 gid
3082                       '(0 0)            ;4 atime
3083                       '(0 0)            ;5 mtime
3084                       '(0 0)            ;6 ctime
3085                       -1                ;7 size
3086                       (concat (if (stringp dirp) "l" (if dirp "d" "-"))
3087                               "?????????") ;8 mode
3088                       nil               ;9 gid weird
3089                       ;; Hack to give remote files a unique "inode number".
3090                       ;; It's actually the sum of the characters in its name.
3091                       (apply '+ (nconc (mapcar 'identity host)
3092                                        (mapcar 'identity user)
3093                                        (mapcar 'identity
3094                                                (directory-file-name name))))
3095                       -1                ;11 device number [v19 only]
3096                       ))))
3097       (ange-ftp-real-file-attributes file))))
3098
3099 (defun ange-ftp-file-writable-p (file)
3100   (setq file (expand-file-name file))
3101   (if (ange-ftp-ftp-name file)
3102       (or (file-exists-p file)          ;guess here for speed
3103           (file-directory-p (file-name-directory file)))
3104     (ange-ftp-real-file-writable-p file)))
3105
3106 (defun ange-ftp-file-readable-p (file)
3107   (setq file (expand-file-name file))
3108   (if (ange-ftp-ftp-name file)
3109       (file-exists-p file)
3110     (ange-ftp-real-file-readable-p file)))
3111
3112 (defun ange-ftp-file-executable-p (file)
3113   (setq file (expand-file-name file))
3114   (if (ange-ftp-ftp-name file)
3115       (file-exists-p file)
3116     (ange-ftp-real-file-executable-p file)))
3117
3118 (defun ange-ftp-delete-file (file)
3119   (interactive "fDelete file: ")
3120   (setq file (expand-file-name file))
3121   (let ((parsed (ange-ftp-ftp-name file)))
3122     (if parsed
3123         (let* ((host (nth 0 parsed))
3124                (user (nth 1 parsed))
3125                (name (ange-ftp-quote-string (nth 2 parsed)))
3126                (abbr (ange-ftp-abbreviate-filename file))
3127                (result (ange-ftp-send-cmd host user
3128                                           (list 'delete name)
3129                                           (format "Deleting %s" abbr))))
3130           (or (car result)
3131               (signal 'ftp-error
3132                       (list
3133                        "Removing old name"
3134                        (format "FTP Error: \"%s\"" (cdr result))
3135                        file)))
3136           (ange-ftp-delete-file-entry file))
3137       (ange-ftp-real-delete-file file))))
3138
3139 (defun ange-ftp-verify-visited-file-modtime (buf)
3140   (let ((name (buffer-file-name buf)))
3141     (if (and (stringp name) (ange-ftp-ftp-name name))
3142         t
3143       (ange-ftp-real-verify-visited-file-modtime buf))))
3144 \f
3145 ;;;; ------------------------------------------------------------
3146 ;;;; File copying support... totally re-written 6/24/92.
3147 ;;;; ------------------------------------------------------------
3148
3149 (defun ange-ftp-barf-or-query-if-file-exists (absname querystring interactive)
3150   (if (file-exists-p absname)
3151       (if (not interactive)
3152           (signal 'file-already-exists (list absname))
3153         (if (not (yes-or-no-p (format "File %s already exists; %s anyway? "
3154                                       absname querystring)))
3155             (signal 'file-already-exists (list absname))))))
3156
3157 ;; async local copy commented out for now since I don't seem to get
3158 ;; the process sentinel called for some processes.
3159 ;;
3160 ;; (defun ange-ftp-copy-file-locally (filename newname ok-if-already-exists
3161 ;;                                          keep-date cont)
3162 ;;   "Kludge to copy a local file and call a continuation when the copy
3163 ;; finishes."
3164 ;;   ;; check to see if we can overwrite
3165 ;;   (if (or (not ok-if-already-exists)
3166 ;;        (numberp ok-if-already-exists))
3167 ;;       (ange-ftp-barf-or-query-if-file-exists newname "copy to it"
3168 ;;                                           (numberp ok-if-already-exists)))
3169 ;;   (let ((proc (start-process " *copy*"
3170 ;;                           (generate-new-buffer "*copy*")
3171 ;;                           "cp"
3172 ;;                           filename
3173 ;;                           newname))
3174 ;;      res)
3175 ;;     (set-process-sentinel proc (function ange-ftp-copy-file-locally-sentinel))
3176 ;;     (process-kill-without-query proc)
3177 ;;     (save-excursion
3178 ;;       (set-buffer (process-buffer proc))
3179 ;;       (make-variable-buffer-local 'copy-cont)
3180 ;;       (setq copy-cont cont))))
3181 ;;
3182 ;; (defun ange-ftp-copy-file-locally-sentinel (proc status)
3183 ;;   (save-excursion
3184 ;;     (set-buffer (process-buffer proc))
3185 ;;     (let ((cont copy-cont)
3186 ;;        (result (buffer-string)))
3187 ;;       (unwind-protect
3188 ;;        (if (and (string-equal status "finished\n")
3189 ;;                 (zerop (length result)))
3190 ;;            (ange-ftp-call-cont cont t nil)
3191 ;;          (ange-ftp-call-cont cont
3192 ;;                              nil
3193 ;;                              (if (zerop (length result))
3194 ;;                                  (substring status 0 -1)
3195 ;;                                (substring result 0 -1))))
3196 ;;      (kill-buffer (current-buffer))))))
3197
3198 ;; this is the extended version of ange-ftp-copy-file-internal that works
3199 ;; asynchronously if asked nicely.
3200 (defun ange-ftp-copy-file-internal (filename newname ok-if-already-exists
3201                                              keep-date &optional msg cont nowait)
3202   (setq filename (expand-file-name filename)
3203         newname (expand-file-name newname))
3204
3205   ;; canonicalize newname if a directory.
3206   (if (file-directory-p newname)
3207       (setq newname (expand-file-name (file-name-nondirectory filename) newname)))
3208
3209   (let ((f-parsed (ange-ftp-ftp-name filename))
3210         (t-parsed (ange-ftp-ftp-name newname)))
3211
3212     ;; local file to local file copy?
3213     (if (and (not f-parsed) (not t-parsed))
3214         (progn
3215           (ange-ftp-real-copy-file filename newname ok-if-already-exists
3216                                    keep-date)
3217           (if cont
3218               (ange-ftp-call-cont cont t "Copied locally")))
3219       ;; one or both files are remote.
3220       (let* ((f-host (and f-parsed (nth 0 f-parsed)))
3221              (f-user (and f-parsed (nth 1 f-parsed)))
3222              (f-name (and f-parsed (ange-ftp-quote-string (nth 2 f-parsed))))
3223              (f-abbr (ange-ftp-abbreviate-filename filename))
3224              (t-host (and t-parsed (nth 0 t-parsed)))
3225              (t-user (and t-parsed (nth 1 t-parsed)))
3226              (t-name (and t-parsed (ange-ftp-quote-string (nth 2 t-parsed))))
3227              (t-abbr (ange-ftp-abbreviate-filename newname filename))
3228              (binary (or (ange-ftp-binary-file filename)
3229                          (ange-ftp-binary-file newname)))
3230              temp1
3231              temp2)
3232
3233         ;; check to see if we can overwrite
3234         (if (or (not ok-if-already-exists)
3235                 (numberp ok-if-already-exists))
3236             (ange-ftp-barf-or-query-if-file-exists newname "copy to it"
3237                                                    (numberp ok-if-already-exists)))
3238
3239         ;; do the copying.
3240         (if f-parsed
3241
3242             ;; filename was remote.
3243             (progn
3244               (if (or (ange-ftp-use-gateway-p f-host)
3245                       t-parsed)
3246                   ;; have to use intermediate file if we are getting via
3247                   ;; gateway machine or we are doing a remote to remote copy.
3248                   (setq temp1 (ange-ftp-make-tmp-name f-host)))
3249
3250               (if binary
3251                   (ange-ftp-set-binary-mode f-host f-user))
3252
3253               (ange-ftp-send-cmd
3254                f-host
3255                f-user
3256                (list 'get f-name (or temp1 newname))
3257                (or msg
3258                    (if (and temp1 t-parsed)
3259                        (format "Getting %s" f-abbr)
3260                      (format "Copying %s to %s" f-abbr t-abbr)))
3261                (list (function ange-ftp-cf1)
3262                      filename newname binary msg
3263                      f-parsed f-host f-user f-name f-abbr
3264                      t-parsed t-host t-user t-name t-abbr
3265                      temp1 temp2 cont nowait)
3266                nowait))
3267
3268           ;; filename wasn't remote.  newname must be remote.  call the
3269           ;; function which does the remainder of the copying work.
3270           (ange-ftp-cf1 t nil
3271                         filename newname binary msg
3272                         f-parsed f-host f-user f-name f-abbr
3273                         t-parsed t-host t-user t-name t-abbr
3274                         nil nil cont nowait))))))
3275
3276 ;; next part of copying routine.
3277 (defun ange-ftp-cf1 (result line
3278                             filename newname binary msg
3279                             f-parsed f-host f-user f-name f-abbr
3280                             t-parsed t-host t-user t-name t-abbr
3281                             temp1 temp2 cont nowait)
3282   (if line
3283       ;; filename must have been remote, and we must have just done a GET.
3284       (unwind-protect
3285           (or result
3286               ;; GET failed for some reason.  Clean up and get out.
3287               (progn
3288                 (and temp1 (ange-ftp-del-tmp-name temp1))
3289                 (or cont
3290                     (signal 'ftp-error (list "Opening input file"
3291                                              (format "FTP Error: \"%s\"" line)
3292                                              filename)))))
3293         ;; cleanup
3294         (if binary
3295             (ange-ftp-set-ascii-mode f-host f-user))))
3296
3297   (if result
3298       ;; We now have to copy either temp1 or filename to newname.
3299       (if t-parsed
3300
3301           ;; newname was remote.
3302           (progn
3303             (if (ange-ftp-use-gateway-p t-host)
3304                 (setq temp2 (ange-ftp-make-tmp-name t-host)))
3305
3306             ;; make sure data is moved into the right place for the
3307             ;; outgoing transfer.  gateway temporary files complicate
3308             ;; things nicely.
3309             (if temp1
3310                 (if temp2
3311                     (if (string-equal temp1 temp2)
3312                         (setq temp1 nil)
3313                       (ange-ftp-real-copy-file temp1 temp2 t))
3314                   (setq temp2 temp1 temp1 nil))
3315               (if temp2
3316                   (ange-ftp-real-copy-file filename temp2 t)))
3317
3318             (if binary
3319                 (ange-ftp-set-binary-mode t-host t-user))
3320
3321             ;; tell the process filter what size the file is.
3322             (let ((attr (file-attributes (or temp2 filename))))
3323               (if attr
3324                   (ange-ftp-set-xfer-size t-host t-user (nth 7 attr))))
3325
3326             (ange-ftp-send-cmd
3327              t-host
3328              t-user
3329              (list 'put (or temp2 filename) t-name)
3330              (or msg
3331                  (if (and temp2 f-parsed)
3332                      (format "Putting %s" newname)
3333                    (format "Copying %s to %s" f-abbr t-abbr)))
3334              (list (function ange-ftp-cf2)
3335                    newname t-host t-user binary temp1 temp2 cont)
3336              nowait))
3337
3338         ;; newname wasn't remote.
3339         (ange-ftp-cf2 t nil newname t-host t-user binary temp1 temp2 cont))
3340
3341     ;; first copy failed, tell caller
3342     (ange-ftp-call-cont cont result line)))
3343
3344 ;; last part of copying routine.
3345 (defun ange-ftp-cf2 (result line newname t-host t-user binary temp1 temp2 cont)
3346   (unwind-protect
3347       (if line
3348           ;; result from doing a local to remote copy.
3349           (unwind-protect
3350               (progn
3351                 (or result
3352                     (or cont
3353                         (signal 'ftp-error
3354                                 (list "Opening output file"
3355                                       (format "FTP Error: \"%s\"" line)
3356                                       newname))))
3357
3358                 (ange-ftp-add-file-entry newname))
3359
3360             ;; cleanup.
3361             (if binary
3362                 (ange-ftp-set-ascii-mode t-host t-user)))
3363
3364         ;; newname was local.
3365         (if temp1
3366             (ange-ftp-real-copy-file temp1 newname t)))
3367
3368     ;; clean up
3369     (and temp1 (ange-ftp-del-tmp-name temp1))
3370     (and temp2 (ange-ftp-del-tmp-name temp2))
3371     (ange-ftp-call-cont cont result line)))
3372
3373 (defun ange-ftp-copy-file (filename newname &optional ok-if-already-exists
3374                                     keep-date)
3375   (interactive "fCopy file: \nFCopy %s to file: \np")
3376   (ange-ftp-copy-file-internal filename
3377                                newname
3378                                ok-if-already-exists
3379                                keep-date
3380                                nil
3381                                nil
3382                                (interactive-p)))
3383 \f
3384 ;;;; ------------------------------------------------------------
3385 ;;;; File renaming support.
3386 ;;;; ------------------------------------------------------------
3387
3388 (defun ange-ftp-rename-remote-to-remote (filename newname f-parsed t-parsed
3389                                                   binary)
3390   "Rename remote file FILE to remote file NEWNAME."
3391   (let ((f-host (nth 0 f-parsed))
3392         (f-user (nth 1 f-parsed))
3393         (t-host (nth 0 t-parsed))
3394         (t-user (nth 1 t-parsed)))
3395     (if (and (string-equal f-host t-host)
3396              (string-equal f-user t-user))
3397         (let* ((f-name (ange-ftp-quote-string (nth 2 f-parsed)))
3398                (t-name (ange-ftp-quote-string (nth 2 t-parsed)))
3399                (cmd (list 'rename f-name t-name))
3400                (fabbr (ange-ftp-abbreviate-filename filename))
3401                (nabbr (ange-ftp-abbreviate-filename newname filename))
3402                (result (ange-ftp-send-cmd f-host f-user cmd
3403                                           (format "Renaming %s to %s"
3404                                                   fabbr
3405                                                   nabbr))))
3406           (or (car result)
3407               (signal 'ftp-error
3408                       (list
3409                        "Renaming"
3410                        (format "FTP Error: \"%s\"" (cdr result))
3411                        filename
3412                        newname)))
3413           (ange-ftp-add-file-entry newname)
3414           (ange-ftp-delete-file-entry filename))
3415       (ange-ftp-copy-file-internal filename newname t nil)
3416       (delete-file filename))))
3417
3418 (defun ange-ftp-rename-local-to-remote (filename newname)
3419   "Rename local FILENAME to remote file NEWNAME."
3420   (let* ((fabbr (ange-ftp-abbreviate-filename filename))
3421          (nabbr (ange-ftp-abbreviate-filename newname filename))
3422          (msg (format "Renaming %s to %s" fabbr nabbr)))
3423     (ange-ftp-copy-file-internal filename newname t nil msg)
3424     (let (ange-ftp-process-verbose)
3425       (delete-file filename))))
3426
3427 (defun ange-ftp-rename-remote-to-local (filename newname)
3428   "Rename remote file FILENAME to local file NEWNAME."
3429   (let* ((fabbr (ange-ftp-abbreviate-filename filename))
3430          (nabbr (ange-ftp-abbreviate-filename newname filename))
3431          (msg (format "Renaming %s to %s" fabbr nabbr)))
3432     (ange-ftp-copy-file-internal filename newname t nil msg)
3433     (let (ange-ftp-process-verbose)
3434       (delete-file filename))))
3435
3436 (defun ange-ftp-rename-file (filename newname &optional ok-if-already-exists)
3437   (interactive "fRename file: \nFRename %s to file: \np")
3438   (setq filename (expand-file-name filename))
3439   (setq newname (expand-file-name newname))
3440   (let* ((f-parsed (ange-ftp-ftp-name filename))
3441          (t-parsed (ange-ftp-ftp-name newname))
3442          (binary (if (or f-parsed t-parsed) (ange-ftp-binary-file filename))))
3443     (if (and (or f-parsed t-parsed)
3444              (or (not ok-if-already-exists)
3445                  (numberp ok-if-already-exists)))
3446         (ange-ftp-barf-or-query-if-file-exists
3447          newname
3448          "rename to it"
3449          (numberp ok-if-already-exists)))
3450     (if f-parsed
3451         (if t-parsed
3452             (ange-ftp-rename-remote-to-remote filename newname f-parsed
3453                                               t-parsed binary)
3454           (ange-ftp-rename-remote-to-local filename newname))
3455       (if t-parsed
3456           (ange-ftp-rename-local-to-remote filename newname)
3457         (ange-ftp-real-rename-file filename newname ok-if-already-exists)))))
3458 \f
3459 ;;;; ------------------------------------------------------------
3460 ;;;; File name completion support.
3461 ;;;; ------------------------------------------------------------
3462
3463 ;; If the file entry SYM is a symlink, returns whether its file exists.
3464 ;; Note that `ange-ftp-this-dir' is used as a free variable.
3465 (defun ange-ftp-file-entry-active-p (sym)
3466   (let ((val (get sym 'val)))
3467     (or (not (stringp val))
3468         (file-exists-p (ange-ftp-expand-symlink val ange-ftp-this-dir)))))
3469
3470 ;; If the file entry is not a directory (nor a symlink pointing to a directory)
3471 ;; returns whether the file (or file pointed to by the symlink) is ignored
3472 ;; by completion-ignored-extensions.
3473 ;; Note that `ange-ftp-this-dir' and `ange-ftp-completion-ignored-pattern'
3474 ;; are used as free variables.
3475 (defun ange-ftp-file-entry-not-ignored-p (sym)
3476   (let ((val (get sym 'val))
3477         (symname (symbol-name sym)))
3478     (if (stringp val)
3479         (let ((file (ange-ftp-expand-symlink val ange-ftp-this-dir)))
3480           (or (file-directory-p file)
3481               (and (file-exists-p file)
3482                    (not (string-match ange-ftp-completion-ignored-pattern
3483                                       symname)))))
3484       (or val ; is a directory name
3485           (not (string-match ange-ftp-completion-ignored-pattern symname))))))
3486
3487 (defun ange-ftp-file-name-all-completions (file dir)
3488   (let ((ange-ftp-this-dir (expand-file-name dir)))
3489     (if (ange-ftp-ftp-name ange-ftp-this-dir)
3490         (progn
3491           (ange-ftp-barf-if-not-directory ange-ftp-this-dir)
3492           (setq ange-ftp-this-dir
3493                 (ange-ftp-real-file-name-as-directory ange-ftp-this-dir))
3494           (let* ((tbl (ange-ftp-get-files ange-ftp-this-dir))
3495                  (completions
3496                   (all-completions file tbl
3497                                    (function ange-ftp-file-entry-active-p))))
3498
3499             ;; see whether each matching file is a directory or not...
3500             (mapcar
3501              (function
3502               (lambda (file)
3503                 (let ((ent (ange-ftp-get-hash-entry file tbl)))
3504                   (if (and ent
3505                            (or (not (stringp ent))
3506                                (file-directory-p
3507                                 (ange-ftp-expand-symlink ent
3508                                                          ange-ftp-this-dir))))
3509                       (concat file "/")
3510                     file))))
3511              completions)))
3512
3513       (if (string-equal "/" ange-ftp-this-dir)
3514           (nconc (all-completions file (ange-ftp-generate-root-prefixes))
3515                  (ange-ftp-real-file-name-all-completions file
3516                                                           ange-ftp-this-dir))
3517         (ange-ftp-real-file-name-all-completions file ange-ftp-this-dir)))))
3518
3519 (defun ange-ftp-file-name-completion (file dir)
3520   (let ((ange-ftp-this-dir (expand-file-name dir)))
3521     (if (ange-ftp-ftp-name ange-ftp-this-dir)
3522         (progn
3523           (ange-ftp-barf-if-not-directory ange-ftp-this-dir)
3524           (if (equal file "")
3525               ""
3526             (setq ange-ftp-this-dir
3527                   (ange-ftp-real-file-name-as-directory ange-ftp-this-dir))     ;real?
3528             (let* ((tbl (ange-ftp-get-files ange-ftp-this-dir))
3529                    (ange-ftp-completion-ignored-pattern
3530                     (mapconcat (function
3531                                 (lambda (s) (if (stringp s)
3532                                                 (concat (regexp-quote s) "$")
3533                                               "/"))) ; / never in filename
3534                                completion-ignored-extensions
3535                                "\\|")))
3536               (ange-ftp-save-match-data
3537                 (or (ange-ftp-file-name-completion-1
3538                      file tbl ange-ftp-this-dir
3539                      (function ange-ftp-file-entry-not-ignored-p))
3540                     (ange-ftp-file-name-completion-1
3541                      file tbl ange-ftp-this-dir
3542                      (function ange-ftp-file-entry-active-p)))))))
3543
3544       (if (string-equal "/" ange-ftp-this-dir)
3545           (try-completion
3546            file
3547            (nconc (ange-ftp-generate-root-prefixes)
3548                   (mapcar 'list
3549                           (ange-ftp-real-file-name-all-completions file "/"))))
3550         (ange-ftp-real-file-name-completion file ange-ftp-this-dir)))))
3551
3552
3553 (defun ange-ftp-file-name-completion-1 (file tbl dir predicate)
3554   (let ((bestmatch (try-completion file tbl predicate)))
3555     (if bestmatch
3556         (if (eq bestmatch t)
3557             (if (file-directory-p (expand-file-name file dir))
3558                 (concat file "/")
3559               t)
3560           (if (and (eq (try-completion bestmatch tbl predicate) t)
3561                    (file-directory-p
3562                     (expand-file-name bestmatch dir)))
3563               (concat bestmatch "/")
3564             bestmatch)))))
3565
3566 ;; Put these lines uncommmented in your .emacs if you want C-r to refresh
3567 ;; ange-ftp's cache whilst doing filename completion.
3568 ;;
3569 ;;(define-key minibuffer-local-completion-map "\C-r" 'ange-ftp-re-read-dir)
3570 ;;(define-key minibuffer-local-must-match-map "\C-r" 'ange-ftp-re-read-dir)
3571
3572 ;; Force a re-read of the directory DIR.  If DIR is omitted then it defaults
3573 ;; to the directory part of the contents of the current buffer.
3574 (defun ange-ftp-re-read-dir (&optional dir)
3575   (interactive)
3576   (if dir
3577       (setq dir (expand-file-name dir))
3578     (setq dir (file-name-directory (expand-file-name (buffer-string)))))
3579   (if (ange-ftp-ftp-name dir)
3580       (progn
3581         (setq ange-ftp-ls-cache-file nil)
3582         (ange-ftp-del-hash-entry dir ange-ftp-files-hashtable)
3583         (ange-ftp-get-files dir t))))
3584 \f
3585 (defun ange-ftp-make-directory (dir &optional parents)
3586   (interactive (list (expand-file-name (read-file-name "Make directory: "))))
3587   (if parents
3588       (let ((parent (file-name-directory (directory-file-name dir))))
3589         (or (file-exists-p parent)
3590             (ange-ftp-make-directory parent parents))))
3591   (if (file-exists-p dir)
3592       (error "Cannot make directory %s: file already exists" dir)
3593     (let ((parsed (ange-ftp-ftp-name dir)))
3594       (if parsed
3595           (let* ((host (nth 0 parsed))
3596                  (user (nth 1 parsed))
3597                  ;; Some ftp's on unix machines (at least on Suns)
3598                  ;; insist that mkdir take a filename, and not a
3599                  ;; directory-name name as an arg. Argh!! This is a bug.
3600                  ;; Non-unix machines will probably always insist
3601                  ;; that mkdir takes a directory-name as an arg
3602                  ;; (as the ftp man page says it should).
3603                  (name (ange-ftp-quote-string
3604                         (if (eq (ange-ftp-host-type host) 'unix)
3605                             (ange-ftp-real-directory-file-name (nth 2 parsed))
3606                           (ange-ftp-real-file-name-as-directory
3607                            (nth 2 parsed)))))
3608                  (abbr (ange-ftp-abbreviate-filename dir))
3609                  (result (ange-ftp-send-cmd host user
3610                                             (list 'mkdir name)
3611                                             (format "Making directory %s"
3612                                                     abbr))))
3613             (or (car result)
3614                 (ange-ftp-error host user
3615                                 (format "Could not make directory %s: %s"
3616                                         dir
3617                                         (cdr result))))
3618             (ange-ftp-add-file-entry dir t))
3619         (ange-ftp-real-make-directory dir)))))
3620
3621 (defun ange-ftp-delete-directory (dir)
3622   (if (file-directory-p dir)
3623       (let ((parsed (ange-ftp-ftp-name dir)))
3624         (if parsed
3625             (let* ((host (nth 0 parsed))
3626                    (user (nth 1 parsed))
3627                    ;; Some ftp's on unix machines (at least on Suns)
3628                    ;; insist that rmdir take a filename, and not a
3629                    ;; directory-name name as an arg. Argh!! This is a bug.
3630                    ;; Non-unix machines will probably always insist
3631                    ;; that rmdir takes a directory-name as an arg
3632                    ;; (as the ftp man page says it should).
3633                    (name (ange-ftp-quote-string
3634                           (if (eq (ange-ftp-host-type host) 'unix)
3635                               (ange-ftp-real-directory-file-name
3636                                (nth 2 parsed))
3637                             (ange-ftp-real-file-name-as-directory
3638                              (nth 2 parsed)))))
3639                   (abbr (ange-ftp-abbreviate-filename dir))
3640                   (result (ange-ftp-send-cmd host user
3641                                              (list 'rmdir name)
3642                                              (format "Removing directory %s"
3643                                                      abbr))))
3644               (or (car result)
3645                   (ange-ftp-error host user
3646                                   (format "Could not remove directory %s: %s"
3647                                           dir
3648                                           (cdr result))))
3649               (ange-ftp-delete-file-entry dir t))
3650           (ange-ftp-real-delete-directory dir)))
3651     (error "Not a directory: %s" dir)))
3652 \f
3653 ;; Make a local copy of FILE and return its name.
3654
3655 (defun ange-ftp-file-local-copy (file)
3656   (let* ((fn1 (expand-file-name file))
3657          (pa1 (ange-ftp-ftp-name fn1)))
3658     (if pa1
3659         (let* ((tmp1 (ange-ftp-make-tmp-name (car pa1)))
3660                (bin1 (ange-ftp-binary-file fn1)))
3661           (ange-ftp-copy-file-internal fn1 tmp1 t nil
3662                                        (format "Getting %s" fn1))
3663           tmp1))))
3664
3665 (defun ange-ftp-load (file &optional noerror nomessage nosuffix)
3666   (if (ange-ftp-ftp-name file)
3667       (let ((tryfiles (if nosuffix
3668                           (list file)
3669                         (list (concat file ".elc") (concat file ".el") file)))
3670             copy)
3671         (while (and tryfiles (not copy))
3672           (condition-case error
3673               (setq copy (ange-ftp-file-local-copy (car tryfiles)))
3674             (ftp-error nil)))
3675         (if copy
3676             (unwind-protect
3677                 (funcall 'load copy noerror nomessage nosuffix)
3678               (delete-file copy))
3679           (or noerror
3680               (signal 'file-error (list "Cannot open load file" file)))))
3681     (ange-ftp-real-load file noerror nomessage nosuffix)))
3682
3683 ;; Calculate default-unhandled-directory for a given ange-ftp buffer.
3684 (defun ange-ftp-unhandled-file-name-directory (filename)
3685   (file-name-directory ange-ftp-tmp-name-template))
3686
3687 \f
3688 ;; Need the following functions for making filenames of compressed
3689 ;; files, because some OS's (unlike UNIX) do not allow a filename to
3690 ;; have two extensions.
3691
3692 (defvar ange-ftp-make-compressed-filename-alist nil
3693   "Alist of host-type-specific functions to process file names for compression.
3694 Each element has the form (TYPE . FUNC).
3695 FUNC should take one argument, a file name, and return a list
3696 of the form (COMPRESSING NEWNAME).
3697 COMPRESSING should be t if the specified file should be compressed,
3698 and nil if it should be uncompressed (that is, if it is a compressed file).
3699 NEWNAME should be the name to give the new compressed or uncompressed file.")
3700
3701 (defun ange-ftp-dired-compress-file (name)
3702   (let ((parsed (ange-ftp-ftp-name name))
3703         conversion-func)
3704     (if (and parsed
3705              (setq conversion-func
3706                    (cdr (assq (ange-ftp-host-type (car parsed))
3707                               ange-ftp-make-compressed-filename-alist))))
3708         (let* ((decision
3709                 (ange-ftp-save-match-data (funcall conversion-func name)))
3710                (compressing (car decision))
3711                (newfile (nth 1 decision)))
3712           (if compressing
3713               (ange-ftp-compress name newfile)
3714             (ange-ftp-uncompress name newfile)))
3715       (let (file-name-handler-alist)
3716         (dired-compress-file name)))))
3717
3718 ;; Copy FILE to this machine, compress it, and copy out to NFILE.
3719 (defun ange-ftp-compress (file nfile)
3720   (let* ((parsed (ange-ftp-ftp-name file))
3721          (tmp1 (ange-ftp-make-tmp-name (car parsed)))
3722          (tmp2 (ange-ftp-make-tmp-name (car parsed)))
3723          (abbr (ange-ftp-abbreviate-filename file))
3724          (nabbr (ange-ftp-abbreviate-filename nfile))
3725          (msg1 (format "Getting %s" abbr))
3726          (msg2 (format "Putting %s" nabbr)))
3727     (unwind-protect
3728         (progn
3729           (ange-ftp-copy-file-internal file tmp1 t nil msg1)
3730           (and ange-ftp-process-verbose
3731                (ange-ftp-message "Compressing %s..." abbr))
3732           (call-process-region (point)
3733                                (point)
3734                                shell-file-name
3735                                nil
3736                                t
3737                                nil
3738                                "-c"
3739                                (format "compress -f -c < %s > %s" tmp1 tmp2))
3740           (and ange-ftp-process-verbose
3741                (ange-ftp-message "Compressing %s...done" abbr))
3742           (if (zerop (buffer-size))
3743               (progn
3744                 (let (ange-ftp-process-verbose)
3745                   (delete-file file))
3746                 (ange-ftp-copy-file-internal tmp2 nfile t nil msg2))))
3747       (ange-ftp-del-tmp-name tmp1)
3748       (ange-ftp-del-tmp-name tmp2))))
3749
3750 ;; Copy FILE to this machine, uncompress it, and copy out to NFILE.
3751 (defun ange-ftp-uncompress (file nfile)
3752   (let* ((parsed (ange-ftp-ftp-name file))
3753          (tmp1 (ange-ftp-make-tmp-name (car parsed)))
3754          (tmp2 (ange-ftp-make-tmp-name (car parsed)))
3755          (abbr (ange-ftp-abbreviate-filename file))
3756          (nabbr (ange-ftp-abbreviate-filename nfile))
3757          (msg1 (format "Getting %s" abbr))
3758          (msg2 (format "Putting %s" nabbr))
3759 ;;       ;; Cheap hack because of problems with binary file transfers from
3760 ;;       ;; VMS hosts.
3761 ;;       (gbinary (not (eq 'vms (ange-ftp-host-type (car parsed)))))
3762          )
3763     (unwind-protect
3764         (progn
3765           (ange-ftp-copy-file-internal file tmp1 t nil msg1)
3766           (and ange-ftp-process-verbose
3767                (ange-ftp-message "Uncompressing %s..." abbr))
3768           (call-process-region (point)
3769                                (point)
3770                                shell-file-name
3771                                nil
3772                                t
3773                                nil
3774                                "-c"
3775                                (format "uncompress -c < %s > %s" tmp1 tmp2))
3776           (and ange-ftp-process-verbose
3777                (ange-ftp-message "Uncompressing %s...done" abbr))
3778           (if (zerop (buffer-size))
3779               (progn
3780                 (let (ange-ftp-process-verbose)
3781                   (delete-file file))
3782                 (ange-ftp-copy-file-internal tmp2 nfile t nil msg2))))
3783       (ange-ftp-del-tmp-name tmp1)
3784       (ange-ftp-del-tmp-name tmp2))))
3785 \f
3786 ;;; Define the handler for special file names
3787 ;;; that causes ange-ftp to be invoked.
3788
3789 ;;;###autoload
3790 (defun ange-ftp-hook-function (operation &rest args)
3791   (let ((fn (get operation 'ange-ftp)))
3792     (if fn (apply fn args)
3793       (ange-ftp-run-real-handler operation args))))
3794
3795
3796 ;;; This regexp takes care of real ange-ftp file names (with a slash
3797 ;;; and colon).
3798 ;;;###autoload
3799 (or (assoc "^/[^/:]*[^/:]:" file-name-handler-alist)
3800     (setq file-name-handler-alist
3801           (cons '("^/[^/:]*[^/:]:" . ange-ftp-hook-function)
3802                 file-name-handler-alist)))
3803
3804 ;;; This regexp recognizes and absolute filenames with only one component,
3805 ;;; for the sake of hostname completion.
3806 ;;;###autoload
3807 (or (assoc "^/[^/:]*\\'" file-name-handler-alist)
3808     (setq file-name-handler-alist
3809           (cons '("^/[^/:]*\\'" . ange-ftp-completion-hook-function)
3810                 file-name-handler-alist)))
3811
3812 ;;; The above two forms are sufficient to cause this file to be loaded
3813 ;;; if the user ever uses a file name with a colon in it.
3814
3815 ;;; This sets the mode
3816 (or (memq 'ange-ftp-set-buffer-mode find-file-hooks)
3817     (setq find-file-hooks
3818           (cons 'ange-ftp-set-buffer-mode find-file-hooks)))
3819
3820 ;;; Now say where to find the handlers for particular operations.
3821
3822 (put 'file-name-directory 'ange-ftp 'ange-ftp-file-name-directory)
3823 (put 'file-name-nondirectory 'ange-ftp 'ange-ftp-file-name-nondirectory)
3824 (put 'file-name-as-directory 'ange-ftp 'ange-ftp-file-name-as-directory)
3825 (put 'directory-file-name 'ange-ftp 'ange-ftp-directory-file-name)
3826 (put 'expand-file-name 'ange-ftp 'ange-ftp-expand-file-name)
3827 (put 'make-directory 'ange-ftp 'ange-ftp-make-directory)
3828 (put 'delete-directory 'ange-ftp 'ange-ftp-delete-directory)
3829 (put 'insert-file-contents 'ange-ftp 'ange-ftp-insert-file-contents)
3830 (put 'directory-files 'ange-ftp 'ange-ftp-directory-files)
3831 (put 'file-directory-p 'ange-ftp 'ange-ftp-file-directory-p)
3832 (put 'file-writable-p 'ange-ftp 'ange-ftp-file-writable-p)
3833 (put 'file-readable-p 'ange-ftp 'ange-ftp-file-readable-p)
3834 (put 'file-executable-p 'ange-ftp 'ange-ftp-file-executable-p)
3835 (put 'file-symlink-p 'ange-ftp 'ange-ftp-file-symlink-p)
3836 (put 'delete-file 'ange-ftp 'ange-ftp-delete-file)
3837 (put 'read-file-name-internal 'ange-ftp 'ange-ftp-read-file-name-internal)
3838 (put 'verify-visited-file-modtime 'ange-ftp
3839      'ange-ftp-verify-visited-file-modtime)
3840 (put 'file-exists-p 'ange-ftp 'ange-ftp-file-exists-p)
3841 (put 'write-region 'ange-ftp 'ange-ftp-write-region)
3842 (put 'backup-buffer 'ange-ftp 'ange-ftp-backup-buffer)
3843 (put 'copy-file 'ange-ftp 'ange-ftp-copy-file)
3844 (put 'rename-file 'ange-ftp 'ange-ftp-rename-file)
3845 (put 'file-attributes 'ange-ftp 'ange-ftp-file-attributes)
3846 (put 'file-name-all-completions 'ange-ftp 'ange-ftp-file-name-all-completions)
3847 (put 'file-name-completion 'ange-ftp 'ange-ftp-file-name-completion)
3848 (put 'insert-directory 'ange-ftp 'ange-ftp-insert-directory)
3849 (put 'file-local-copy 'ange-ftp 'ange-ftp-file-local-copy)
3850 (put 'unhandled-file-name-directory 'ange-ftp
3851      'ange-ftp-unhandled-file-name-directory)
3852 (put 'file-name-sans-versions 'ange-ftp 'ange-ftp-file-name-sans-versions)
3853 (put 'dired-uncache 'ange-ftp 'ange-ftp-dired-uncache)
3854 (put 'dired-compress-file 'ange-ftp 'ange-ftp-dired-compress-file)
3855 (put 'load 'ange-ftp 'ange-ftp-load)
3856
3857 ;; Turn off truename processing to save time.
3858 ;; Treat each name as its own truename.
3859 (put 'file-truename 'ange-ftp 'identity)
3860
3861 ;; Turn off RCS/SCCS processing to save time.
3862 ;; This returns nil for any file name as argument.
3863 (put 'vc-registered 'ange-ftp 'null)
3864 \f
3865 ;;; Define ways of getting at unmodified Emacs primitives,
3866 ;;; turning off our handler.
3867
3868 (defun ange-ftp-run-real-handler (operation args)
3869   (let ((inhibit-file-name-handlers
3870          (cons 'ange-ftp-hook-function
3871                (cons 'ange-ftp-completion-hook-function
3872                      (and (eq inhibit-file-name-operation operation)
3873                           inhibit-file-name-handlers))))
3874         (inhibit-file-name-operation operation))
3875     (apply operation args)))
3876
3877 (defun ange-ftp-real-file-name-directory (&rest args)
3878   (ange-ftp-run-real-handler 'file-name-directory args))
3879 (defun ange-ftp-real-file-name-nondirectory (&rest args)
3880   (ange-ftp-run-real-handler 'file-name-nondirectory args))
3881 (defun ange-ftp-real-file-name-as-directory (&rest args)
3882   (ange-ftp-run-real-handler 'file-name-as-directory args))
3883 (defun ange-ftp-real-directory-file-name (&rest args)
3884   (ange-ftp-run-real-handler 'directory-file-name args))
3885 (defun ange-ftp-real-expand-file-name (&rest args)
3886   (ange-ftp-run-real-handler 'expand-file-name args))
3887 (defun ange-ftp-real-make-directory (&rest args)
3888   (ange-ftp-run-real-handler 'make-directory args))
3889 (defun ange-ftp-real-delete-directory (&rest args)
3890   (ange-ftp-run-real-handler 'delete-directory args))
3891 (defun ange-ftp-real-insert-file-contents (&rest args)
3892   (ange-ftp-run-real-handler 'insert-file-contents args))
3893 (defun ange-ftp-real-directory-files (&rest args)
3894   (ange-ftp-run-real-handler 'directory-files args))
3895 (defun ange-ftp-real-file-directory-p (&rest args)
3896   (ange-ftp-run-real-handler 'file-directory-p args))
3897 (defun ange-ftp-real-file-writable-p (&rest args)
3898   (ange-ftp-run-real-handler 'file-writable-p args))
3899 (defun ange-ftp-real-file-readable-p (&rest args)
3900   (ange-ftp-run-real-handler 'file-readable-p args))
3901 (defun ange-ftp-real-file-executable-p (&rest args)
3902   (ange-ftp-run-real-handler 'file-executable-p args))
3903 (defun ange-ftp-real-file-symlink-p (&rest args)
3904   (ange-ftp-run-real-handler 'file-symlink-p args))
3905 (defun ange-ftp-real-delete-file (&rest args)
3906   (ange-ftp-run-real-handler 'delete-file args))
3907 (defun ange-ftp-real-read-file-name-internal (&rest args)
3908   (ange-ftp-run-real-handler 'read-file-name-internal args))
3909 (defun ange-ftp-real-verify-visited-file-modtime (&rest args)
3910   (ange-ftp-run-real-handler 'verify-visited-file-modtime args))
3911 (defun ange-ftp-real-file-exists-p (&rest args)
3912   (ange-ftp-run-real-handler 'file-exists-p args))
3913 (defun ange-ftp-real-write-region (&rest args)
3914   (ange-ftp-run-real-handler 'write-region args))
3915 (defun ange-ftp-real-backup-buffer (&rest args)
3916   (ange-ftp-run-real-handler 'backup-buffer args))
3917 (defun ange-ftp-real-copy-file (&rest args)
3918   (ange-ftp-run-real-handler 'copy-file args))
3919 (defun ange-ftp-real-rename-file (&rest args)
3920   (ange-ftp-run-real-handler 'rename-file args))
3921 (defun ange-ftp-real-file-attributes (&rest args)
3922   (ange-ftp-run-real-handler 'file-attributes args))
3923 (defun ange-ftp-real-file-name-all-completions (&rest args)
3924   (ange-ftp-run-real-handler 'file-name-all-completions args))
3925 (defun ange-ftp-real-file-name-completion (&rest args)
3926   (ange-ftp-run-real-handler 'file-name-completion args))
3927 (defun ange-ftp-real-insert-directory (&rest args)
3928   (ange-ftp-run-real-handler 'insert-directory args))
3929 (defun ange-ftp-real-file-name-sans-versions (&rest args)
3930   (ange-ftp-run-real-handler 'file-name-sans-versions args))
3931 (defun ange-ftp-real-shell-command (&rest args)
3932   (ange-ftp-run-real-handler 'shell-command args))
3933 (defun ange-ftp-real-load (&rest args)
3934   (ange-ftp-run-real-handler 'load args))
3935 \f
3936 ;; Here we support using dired on remote hosts.
3937 ;; I have turned off the support for using dired on foreign directory formats.
3938 ;; That involves too many unclean hooks.
3939 ;; It would be cleaner to support such operations by
3940 ;; converting the foreign directory format to something dired can understand;
3941 ;; something close to ls -l output.
3942 ;; The logical place to do this is in the functions ange-ftp-parse-...-listing.
3943
3944 ;; Some of the old dired hooks would still be needed even if this is done.
3945 ;; I have preserved (and modernized) those hooks.
3946 ;; So the format conversion should be all that is needed.
3947
3948 (defun ange-ftp-insert-directory (file switches &optional wildcard full)
3949   (let ((short (ange-ftp-abbreviate-filename file))
3950         (parsed (ange-ftp-ftp-name file)))
3951     (if parsed
3952         (insert
3953          (if wildcard
3954              (let ((default-directory (file-name-directory file)))
3955                (ange-ftp-ls (file-name-nondirectory file) switches nil nil t))
3956            (ange-ftp-ls file switches full)))
3957       (ange-ftp-real-insert-directory file switches wildcard full))))
3958
3959 (defun ange-ftp-dired-uncache (dir)
3960   (if (ange-ftp-ftp-name (expand-file-name dir))
3961       (setq ange-ftp-ls-cache-file nil)))
3962
3963 (defvar ange-ftp-sans-version-alist nil
3964   "Alist of mapping host type into function to remove file version numbers.")
3965
3966 (defun ange-ftp-file-name-sans-versions (file keep-backup-version)
3967   (setq file (ange-ftp-abbreviate-filename file))
3968   (let ((parsed (ange-ftp-ftp-name file))
3969         host-type func)
3970     (if parsed
3971         (setq host-type (ange-ftp-host-type (car parsed))
3972               func (cdr (assq (ange-ftp-host-type (car parsed))
3973                               ange-ftp-sans-version-alist))))
3974     (if func (funcall func file keep-backup-version)
3975       (ange-ftp-real-file-name-sans-versions file keep-backup-version))))
3976
3977 (defvar ange-ftp-remote-shell-file-name
3978   (if (memq system-type '(hpux usg-unix-v)) ; hope that's right
3979       "remsh"
3980     "rsh")
3981   "Name of command to run a remote shell, for ange-ftp.")
3982
3983 ;;; This doesn't work yet; a new hook needs to be created.
3984 ;;; Maybe the new hook should be in call-process.
3985 (defun ange-ftp-shell-command (command)
3986   (let* ((parsed (ange-ftp-ftp-name default-directory))
3987          (host (nth 0 parsed))
3988          (user (nth 1 parsed))
3989          (name (nth 2 parsed)))
3990     (if (not parsed)
3991         (ange-ftp-real-shell-command command)
3992       (if (> (length name) 0)           ; else it's $HOME
3993           (setq command (concat "cd " name "; " command)))
3994       (setq command
3995             (format  "%s %s \"%s\""     ; remsh -l USER does not work well
3996                                         ; on a hp-ux machine I tried
3997                      ange-ftp-remote-shell-file-name host command))
3998       (ange-ftp-message "Remote command '%s' ..." command)
3999       ;; Cannot call ange-ftp-real-dired-run-shell-command here as it
4000       ;; would prepend "cd default-directory" --- which bombs because
4001       ;; default-directory is in ange-ftp syntax for remote file names.
4002       (ange-ftp-real-shell-command command))))
4003
4004 ;;; Thisis not hooked up yet.
4005 (defun ange-ftp-dired-call-process (program discard &rest arguments)
4006   ;; PROGRAM is always one of those below in the cond in dired.el.
4007   ;; The ARGUMENTS are (nearly) always files.
4008   (if (ange-ftp-ftp-name default-directory)
4009       ;; Can't use ange-ftp-dired-host-type here because the current
4010       ;; buffer is *dired-check-process output*
4011       (condition-case oops
4012           (cond ((equal "chmod" program)
4013                  (ange-ftp-call-chmod arguments))
4014                 ;; ((equal "chgrp" program))
4015                 ;; ((equal dired-chown-program program))
4016                 (t (error "Unknown remote command: %s" program)))
4017         (ftp-error (insert (format "%s: %s, %s\n"
4018                                     (nth 1 oops)
4019                                     (nth 2 oops)
4020                                     (nth 3 oops))))
4021         (error (insert (format "%s\n" (nth 1 oops)))))
4022     (apply 'call-process program nil (not discard) nil arguments)))
4023
4024 ;;; This currently does not work; it is never called.
4025 (defun ange-ftp-call-chmod (args)
4026   (if (< (length args) 2)
4027       (error "ange-ftp-call-chmod: missing mode and/or filename: %s" args))
4028   (let ((mode (car args)))
4029     (mapcar
4030      (function
4031       (lambda (file)
4032         (setq file (expand-file-name file))
4033         (let ((parsed (ange-ftp-ftp-name file)))
4034           (if parsed
4035               (let* ((host (nth 0 parsed))
4036                      (user (nth 1 parsed))
4037                      (name (ange-ftp-quote-string (nth 2 parsed)))
4038                      (abbr (ange-ftp-abbreviate-filename file))
4039                      (result (ange-ftp-send-cmd host user
4040                                                 (list 'chmod mode name)
4041                                                 (format "doing chmod %s"
4042                                                         abbr))))
4043                 (or (car result)
4044                     (ange-ftp-error host user
4045                                     (format "chmod: %s: \"%s\""
4046                                             file
4047                                             (cdr result)))))))))
4048      (cdr args)))
4049   (setq ange-ftp-ls-cache-file nil))    ;stop confusing dired
4050 \f
4051 ;;; This is turned off because it has nothing properly to do
4052 ;;; with dired.  It could be reasonable to adapt this to
4053 ;;; replace ange-ftp-copy-file.
4054
4055 ;;;;; ------------------------------------------------------------
4056 ;;;;; Noddy support for async copy-file within dired.
4057 ;;;;; ------------------------------------------------------------
4058
4059 ;;(defun ange-ftp-dired-copy-file (from to ok-flag &optional cont nowait)
4060 ;;  "Documented as original."
4061 ;;  (dired-handle-overwrite to)
4062 ;;  (ange-ftp-copy-file-internal from to ok-flag dired-copy-preserve-time nil
4063 ;;                             cont nowait))
4064
4065 ;;(defun ange-ftp-dired-do-create-files (op-symbol file-creator operation arg
4066 ;;                                               &optional marker-char op1
4067 ;;                                               how-to)
4068 ;;  "Documented as original."
4069 ;;  ;; we need to let ange-ftp-dired-create-files know that we indirectly
4070 ;;  ;; called it rather than somebody else.
4071 ;;  (let ((ange-ftp-dired-do-create-files t)) ; tell who caller is
4072 ;;    (ange-ftp-real-dired-do-create-files op-symbol file-creator operation
4073 ;;                                       arg marker-char op1 how-to)))
4074
4075 ;;(defun ange-ftp-dired-create-files (file-creator operation fn-list name-constructor
4076 ;;                                               &optional marker-char)
4077 ;;  "Documented as original."
4078 ;;  (if (and (boundp 'ange-ftp-dired-do-create-files)
4079 ;;         ;; called from ange-ftp-dired-do-create-files?
4080 ;;         ange-ftp-dired-do-create-files
4081 ;;         ;; any files worth copying?
4082 ;;         fn-list
4083 ;;         ;; we only support async copy-file at the mo.
4084 ;;         (eq file-creator 'dired-copy-file)
4085 ;;         ;; it is only worth calling the alternative function for remote files
4086 ;;         ;; as we tie ourself in recursive knots otherwise.
4087 ;;         (or (ange-ftp-ftp-name (car fn-list))
4088 ;;             ;; we can only call the name constructor for dired-do-create-files
4089 ;;             ;; since the one for regexps starts prompting here, there and
4090 ;;             ;; everywhere.
4091 ;;             (ange-ftp-ftp-name (funcall name-constructor (car fn-list)))))
4092 ;;      ;; use the process-filter driven routine rather than the iterative one.
4093 ;;      (ange-ftp-dcf-1 file-creator
4094 ;;                    operation
4095 ;;                    fn-list
4096 ;;                    name-constructor
4097 ;;                    (and (boundp 'target) target)     ;dynamically bound
4098 ;;                    marker-char
4099 ;;                    (current-buffer)
4100 ;;                    nil       ;overwrite-query
4101 ;;                    nil       ;overwrite-backup-query
4102 ;;                    nil       ;failures
4103 ;;                    nil       ;skipped
4104 ;;                    0         ;success-count
4105 ;;                    (length fn-list) ;total
4106 ;;                    )
4107 ;;    ;; normal case... use the interactive routine... much cheaper.
4108 ;;    (ange-ftp-real-dired-create-files file-creator operation fn-list
4109 ;;                                    name-constructor marker-char)))
4110
4111 ;;(defun ange-ftp-dcf-1 (file-creator operation fn-list name-constructor
4112 ;;                     target marker-char buffer overwrite-query
4113 ;;                     overwrite-backup-query failures skipped
4114 ;;                     success-count total)
4115 ;;  (let ((old-buf (current-buffer)))
4116 ;;    (unwind-protect
4117 ;;      (progn
4118 ;;        (set-buffer buffer)
4119 ;;        (if (null fn-list)
4120 ;;            (ange-ftp-dcf-3 failures operation total skipped
4121 ;;                            success-count buffer)
4122
4123 ;;          (let* ((from (car fn-list))
4124 ;;                 (to (funcall name-constructor from)))
4125 ;;            (if (equal to from)
4126 ;;                (progn
4127 ;;                  (setq to nil)
4128 ;;                  (dired-log "Cannot %s to same file: %s\n"
4129 ;;                             (downcase operation) from)))
4130 ;;            (if (not to)
4131 ;;                (ange-ftp-dcf-1 file-creator
4132 ;;                                operation
4133 ;;                                (cdr fn-list)
4134 ;;                                name-constructor
4135 ;;                                target
4136 ;;                                marker-char
4137 ;;                                buffer
4138 ;;                                overwrite-query
4139 ;;                                overwrite-backup-query
4140 ;;                                failures
4141 ;;                                (cons (dired-make-relative from) skipped)
4142 ;;                                success-count
4143 ;;                                total)
4144 ;;              (let* ((overwrite (file-exists-p to))
4145 ;;                     (overwrite-confirmed     ; for dired-handle-overwrite
4146 ;;                      (and overwrite
4147 ;;                           (let ((help-form '(format "\
4148 ;;Type SPC or `y' to overwrite file `%s',
4149 ;;DEL or `n' to skip to next,
4150 ;;ESC or `q' to not overwrite any of the remaining files,
4151 ;;`!' to overwrite all remaining files with no more questions." to)))
4152 ;;                             (dired-query 'overwrite-query
4153 ;;                                          "Overwrite `%s'?" to))))
4154 ;;                     ;; must determine if FROM is marked before file-creator
4155 ;;                     ;; gets a chance to delete it (in case of a move).
4156 ;;                     (actual-marker-char
4157 ;;                      (cond  ((integerp marker-char) marker-char)
4158 ;;                             (marker-char (dired-file-marker from)) ; slow
4159 ;;                             (t nil))))
4160 ;;                (condition-case err
4161 ;;                    (funcall file-creator from to overwrite-confirmed
4162 ;;                             (list (function ange-ftp-dcf-2)
4163 ;;                                   nil        ;err
4164 ;;                                   file-creator operation fn-list
4165 ;;                                   name-constructor
4166 ;;                                   target
4167 ;;                                   marker-char actual-marker-char
4168 ;;                                   buffer to from
4169 ;;                                   overwrite
4170 ;;                                   overwrite-confirmed
4171 ;;                                   overwrite-query
4172 ;;                                   overwrite-backup-query
4173 ;;                                   failures skipped success-count
4174 ;;                                   total)
4175 ;;                             t)
4176 ;;                  (file-error         ; FILE-CREATOR aborted
4177 ;;                   (ange-ftp-dcf-2 nil ;result
4178 ;;                                   nil ;line
4179 ;;                                   err
4180 ;;                                   file-creator operation fn-list
4181 ;;                                   name-constructor
4182 ;;                                   target
4183 ;;                                   marker-char actual-marker-char
4184 ;;                                   buffer to from
4185 ;;                                   overwrite
4186 ;;                                   overwrite-confirmed
4187 ;;                                   overwrite-query
4188 ;;                                   overwrite-backup-query
4189 ;;                                   failures skipped success-count
4190 ;;                                   total))))))))
4191 ;;      (set-buffer old-buf))))
4192
4193 ;;(defun ange-ftp-dcf-2 (result line err
4194 ;;                            file-creator operation fn-list
4195 ;;                            name-constructor
4196 ;;                            target
4197 ;;                            marker-char actual-marker-char
4198 ;;                            buffer to from
4199 ;;                            overwrite
4200 ;;                            overwrite-confirmed
4201 ;;                            overwrite-query
4202 ;;                            overwrite-backup-query
4203 ;;                            failures skipped success-count
4204 ;;                            total)
4205 ;;  (let ((old-buf (current-buffer)))
4206 ;;    (unwind-protect
4207 ;;      (progn
4208 ;;        (set-buffer buffer)
4209 ;;        (if (or err (not result))
4210 ;;            (progn
4211 ;;              (setq failures (cons (dired-make-relative from) failures))
4212 ;;              (dired-log "%s `%s' to `%s' failed:\n%s\n"
4213 ;;                         operation from to (or err line)))
4214 ;;          (if overwrite
4215 ;;              ;; If we get here, file-creator hasn't been aborted
4216 ;;              ;; and the old entry (if any) has to be deleted
4217 ;;              ;; before adding the new entry.
4218 ;;              (dired-remove-file to))
4219 ;;          (setq success-count (1+ success-count))
4220 ;;          (message "%s: %d of %d" operation success-count total)
4221 ;;          (dired-add-file to actual-marker-char))
4222
4223 ;;        (ange-ftp-dcf-1 file-creator operation (cdr fn-list)
4224 ;;                        name-constructor
4225 ;;                        target
4226 ;;                        marker-char
4227 ;;                        buffer
4228 ;;                        overwrite-query
4229 ;;                        overwrite-backup-query
4230 ;;                        failures skipped success-count
4231 ;;                        total))
4232 ;;      (set-buffer old-buf))))
4233
4234 ;;(defun ange-ftp-dcf-3 (failures operation total skipped success-count
4235 ;;                              buffer)
4236 ;;  (let ((old-buf (current-buffer)))
4237 ;;    (unwind-protect
4238 ;;      (progn
4239 ;;        (set-buffer buffer)
4240 ;;        (cond
4241 ;;         (failures
4242 ;;          (dired-log-summary
4243 ;;           (message "%s failed for %d of %d file%s %s"
4244 ;;                    operation (length failures) total
4245 ;;                    (dired-plural-s total) failures)))
4246 ;;         (skipped
4247 ;;          (dired-log-summary
4248 ;;           (message "%s: %d of %d file%s skipped %s"
4249 ;;                    operation (length skipped) total
4250 ;;                    (dired-plural-s total) skipped)))
4251 ;;         (t
4252 ;;          (message "%s: %s file%s."
4253 ;;                   operation success-count (dired-plural-s success-count))))
4254 ;;        (dired-move-to-filename))
4255 ;;      (set-buffer old-buf))))
4256 \f
4257 ;;;; -----------------------------------------------
4258 ;;;; Unix Descriptive Listing (dl) Support
4259 ;;;; -----------------------------------------------
4260
4261 ;; This is turned off because nothing uses it currently
4262 ;; and because I don't understand what it's supposed to be for. --rms.
4263
4264 ;;(defconst ange-ftp-dired-dl-re-dir
4265 ;;  "^. [^ /]+/[ \n]"
4266 ;;  "Regular expression to use to search for dl directories.")
4267
4268 ;;(or (assq 'unix:dl ange-ftp-dired-re-dir-alist)
4269 ;;    (setq ange-ftp-dired-re-dir-alist
4270 ;;        (cons (cons 'unix:dl  ange-ftp-dired-dl-re-dir)
4271 ;;              ange-ftp-dired-re-dir-alist)))
4272
4273 ;;(defun ange-ftp-dired-dl-move-to-filename (&optional raise-error eol)
4274 ;;  "In dired, move to the first character of the filename on this line."
4275 ;;  ;; This is the Unix dl version.
4276 ;;  (or eol (setq eol (progn (end-of-line) (point))))
4277 ;;  (let (case-fold-search)
4278 ;;    (beginning-of-line)
4279 ;;    (if (looking-at ". [^ ]+ +\\([0-9]+\\|-\\|=\\) ")
4280 ;;      (goto-char (+ (point) 2))
4281 ;;      (if raise-error
4282 ;;        (error "No file on this line")
4283 ;;      nil))))
4284
4285 ;;(or (assq 'unix:dl ange-ftp-dired-move-to-filename-alist)
4286 ;;    (setq ange-ftp-dired-move-to-filename-alist
4287 ;;        (cons '(unix:dl . ange-ftp-dired-dl-move-to-filename)
4288 ;;              ange-ftp-dired-move-to-filename-alist)))
4289
4290 ;;(defun ange-ftp-dired-dl-move-to-end-of-filename (&optional no-error eol)
4291 ;;  ;; Assumes point is at beginning of filename.
4292 ;;  ;; So, it should be called only after (dired-move-to-filename t).
4293 ;;  ;; On failure, signals an error or returns nil.
4294 ;;  ;; This is the Unix dl version.
4295 ;;  (let ((opoint (point))
4296 ;;      case-fold-search hidden)
4297 ;;    (or eol (setq eol (save-excursion (end-of-line) (point))))
4298 ;;    (setq hidden (and selective-display
4299 ;;                     (save-excursion
4300 ;;                       (search-forward "\r" eol t))))
4301 ;;    (if hidden
4302 ;;      (if no-error
4303 ;;          nil
4304 ;;        (error
4305 ;;         (substitute-command-keys
4306 ;;          "File line is hidden, type \\[dired-hide-subdir] to unhide")))
4307 ;;      (skip-chars-forward "^ /" eol)
4308 ;;      (if (eq opoint (point))
4309 ;;        (if no-error
4310 ;;            nil
4311 ;;          (error "No file on this line"))
4312 ;;      (point)))))
4313
4314 ;;(or (assq 'unix:dl ange-ftp-dired-move-to-end-of-filename-alist)
4315 ;;    (setq ange-ftp-dired-move-to-end-of-filename-alist
4316 ;;        (cons '(unix:dl . ange-ftp-dired-dl-move-to-end-of-filename)
4317 ;;              ange-ftp-dired-move-to-end-of-filename-alist)))
4318 \f
4319 ;;;; ------------------------------------------------------------
4320 ;;;; VOS support (VOS support is probably broken,
4321 ;;;; but I don't know anything about VOS.)
4322 ;;;; ------------------------------------------------------------
4323 ;
4324 ;(defun ange-ftp-fix-name-for-vos (name &optional reverse)
4325 ;  (setq name (copy-sequence name))
4326 ;  (let ((from (if reverse ?\> ?\/))
4327 ;       (to (if reverse ?\/ ?\>))
4328 ;       (i (1- (length name))))
4329 ;    (while (>= i 0)
4330 ;      (if (= (aref name i) from)
4331 ;         (aset name i to))
4332 ;      (setq i (1- i)))
4333 ;    name))
4334 ;
4335 ;(or (assq 'vos ange-ftp-fix-name-func-alist)
4336 ;    (setq ange-ftp-fix-name-func-alist
4337 ;         (cons '(vos . ange-ftp-fix-name-for-vos)
4338 ;               ange-ftp-fix-name-func-alist)))
4339 ;
4340 ;(or (memq 'vos ange-ftp-dumb-host-types)
4341 ;    (setq ange-ftp-dumb-host-types
4342 ;         (cons 'vos ange-ftp-dumb-host-types)))
4343 ;
4344 ;(defun ange-ftp-fix-dir-name-for-vos (dir-name)
4345 ;  (ange-ftp-fix-name-for-vos
4346 ;   (concat dir-name
4347 ;          (if (eq ?/ (aref dir-name (1- (length dir-name))))
4348 ;              "" "/")
4349 ;          "*")))
4350 ;
4351 ;(or (assq 'vos ange-ftp-fix-dir-name-func-alist)
4352 ;    (setq ange-ftp-fix-dir-name-func-alist
4353 ;         (cons '(vos . ange-ftp-fix-dir-name-for-vos)
4354 ;               ange-ftp-fix-dir-name-func-alist)))
4355 ;
4356 ;(defvar ange-ftp-vos-host-regexp nil
4357 ;  "If a host matches this regexp then it is assumed to be running VOS.")
4358 ;
4359 ;(defun ange-ftp-vos-host (host)
4360 ;  (and ange-ftp-vos-host-regexp
4361 ;       (ange-ftp-save-match-data
4362 ;        (string-match ange-ftp-vos-host-regexp host))))
4363 ;
4364 ;(defun ange-ftp-parse-vos-listing ()
4365 ;  "Parse the current buffer which is assumed to be in VOS list -all
4366 ;format, and return a hashtable as the result."
4367 ;  (let ((tbl (ange-ftp-make-hashtable))
4368 ;       (type-list
4369 ;        '(("^Files: [0-9]+ +Blocks: [0-9]+\n+" nil 40)
4370 ;          ("^Dirs: [0-9]+\n+" t 30)))
4371 ;       type-regexp type-is-dir type-col file)
4372 ;    (goto-char (point-min))
4373 ;    (ange-ftp-save-match-data
4374 ;      (while type-list
4375 ;       (setq type-regexp (car (car type-list))
4376 ;             type-is-dir (nth 1 (car type-list))
4377 ;             type-col (nth 2 (car type-list))
4378 ;             type-list (cdr type-list))
4379 ;       (if (re-search-forward type-regexp nil t)
4380 ;           (while (eq (char-after (point)) ? )
4381 ;             (move-to-column type-col)
4382 ;             (setq file (buffer-substring (point)
4383 ;                                          (progn
4384 ;                                            (end-of-line 1)
4385 ;                                            (point))))
4386 ;             (ange-ftp-put-hash-entry file type-is-dir tbl)
4387 ;             (forward-line 1))))
4388 ;      (ange-ftp-put-hash-entry "." 'vosdir tbl)
4389 ;      (ange-ftp-put-hash-entry ".." 'vosdir tbl))
4390 ;    tbl))
4391 ;
4392 ;(or (assq 'vos ange-ftp-parse-list-func-alist)
4393 ;    (setq ange-ftp-parse-list-func-alist
4394 ;         (cons '(vos . ange-ftp-parse-vos-listing)
4395 ;               ange-ftp-parse-list-func-alist)))
4396 \f
4397 ;;;; ------------------------------------------------------------
4398 ;;;; VMS support.
4399 ;;;; ------------------------------------------------------------
4400
4401 ;; Convert NAME from UNIX-ish to VMS.  If REVERSE given then convert from VMS
4402 ;; to UNIX-ish.
4403 (defun ange-ftp-fix-name-for-vms (name &optional reverse)
4404   (ange-ftp-save-match-data
4405     (if reverse
4406         (if (string-match "^\\([^:]+:\\)?\\(\\[.*\\]\\)?\\([^][]*\\)$" name)
4407             (let (drive dir file)
4408               (if (match-beginning 1)
4409                   (setq drive (substring name
4410                                          (match-beginning 1)
4411                                          (match-end 1))))
4412               (if (match-beginning 2)
4413                   (setq dir
4414                         (substring name (match-beginning 2) (match-end 2))))
4415               (if (match-beginning 3)
4416                   (setq file
4417                         (substring name (match-beginning 3) (match-end 3))))
4418               (and dir
4419                    (setq dir (apply (function concat)
4420                                     (mapcar (function
4421                                              (lambda (char)
4422                                                (if (= char ?.)
4423                                                    (vector ?/)
4424                                                  (vector char))))
4425                                             (substring dir 1 -1)))))
4426               (concat (and drive
4427                            (concat "/" drive "/"))
4428                       dir (and dir "/")
4429                       file))
4430           (error "name %s didn't match" name))
4431       (let (drive dir file tmp)
4432         (if (string-match "^/[^:]+:/" name)
4433             (setq drive (substring name 1
4434                                    (1- (match-end 0)))
4435                   name (substring name (match-end 0))))
4436         (setq tmp (file-name-directory name))
4437         (if tmp
4438             (setq dir (apply (function concat)
4439                              (mapcar (function
4440                                       (lambda (char)
4441                                         (if (= char ?/)
4442                                             (vector ?.)
4443                                           (vector char))))
4444                                      (substring tmp 0 -1)))))
4445         (setq file (file-name-nondirectory name))
4446         (concat drive
4447                 (and dir (concat "[" (if drive nil ".") dir "]"))
4448                 file)))))
4449
4450 ;; (ange-ftp-fix-name-for-vms "/PUB$:/ANONYMOUS/SDSCPUB/NEXT/Readme.txt;1")
4451 ;; (ange-ftp-fix-name-for-vms "/PUB$:[ANONYMOUS.SDSCPUB.NEXT]Readme.txt;1" t)
4452
4453 (or (assq 'vms ange-ftp-fix-name-func-alist)
4454     (setq ange-ftp-fix-name-func-alist
4455           (cons '(vms . ange-ftp-fix-name-for-vms)
4456                 ange-ftp-fix-name-func-alist)))
4457
4458 (or (memq 'vms ange-ftp-dumb-host-types)
4459     (setq ange-ftp-dumb-host-types
4460           (cons 'vms ange-ftp-dumb-host-types)))
4461
4462 ;; It is important that this function barf for directories for which we know
4463 ;; that we cannot possibly get a directory listing, such as "/" and "/DEV:/".
4464 ;; This is because it saves an unnecessary FTP error, or possibly the listing
4465 ;; might succeed, but give erroneous info. This last case is particularly
4466 ;; likely for OS's (like MTS) for which we need to use a wildcard in order
4467 ;; to list a directory.
4468
4469 ;; Convert name from UNIX-ish to VMS ready for a DIRectory listing.
4470 (defun ange-ftp-fix-dir-name-for-vms (dir-name)
4471   ;; Should there be entries for .. -> [-] and . -> [] below. Don't
4472   ;; think so, because expand-filename should have already short-circuited
4473   ;; them.
4474   (cond ((string-equal dir-name "/")
4475          (error "Cannot get listing for fictitious \"/\" directory."))
4476         ((string-match "^/[-A-Z0-9_$]+:/$" dir-name)
4477          (error "Cannot get listing for device."))
4478         ((ange-ftp-fix-name-for-vms dir-name))))
4479
4480 (or (assq 'vms ange-ftp-fix-dir-name-func-alist)
4481     (setq ange-ftp-fix-dir-name-func-alist
4482           (cons '(vms . ange-ftp-fix-dir-name-for-vms)
4483                 ange-ftp-fix-dir-name-func-alist)))
4484
4485 (defvar ange-ftp-vms-host-regexp nil)
4486
4487 ;; Return non-nil if HOST is running VMS.
4488 (defun ange-ftp-vms-host (host)
4489   (and ange-ftp-vms-host-regexp
4490        (ange-ftp-save-match-data
4491          (string-match ange-ftp-vms-host-regexp host))))
4492
4493 ;; Because some VMS ftp servers convert filenames to lower case
4494 ;; we allow a-z in the filename regexp. I'm not too happy about this.
4495
4496 (defconst ange-ftp-vms-filename-regexp
4497   (concat
4498    "\\(\\([_A-Za-z0-9$]?\\|[_A-Za-z0-9$][-_A-Za-z0-9$]*\\)\\."
4499    "[-_A-Za-z0-9$]*;+[0-9]*\\)")
4500   "Regular expression to match for a valid VMS file name in Dired buffer.
4501 Stupid freaking bug! Position of _ and $ shouldn't matter but they do.
4502 Having [A-Z0-9$_] bombs on filename _$$CHANGE_LOG$.TXT$ and $CHANGE_LOG$.TX
4503 Other orders of $ and _ seem to all work just fine.")
4504
4505 ;; These parsing functions are as general as possible because the syntax
4506 ;; of ftp listings from VMS hosts is a bit erratic. What saves us is that
4507 ;; the VMS filename syntax is so rigid. If they bomb on a listing in the
4508 ;; standard VMS Multinet format, then this is a bug. If they bomb on a listing
4509 ;; from vms.weird.net, then too bad.
4510
4511 ;; Extract the next filename from a VMS dired-like listing.
4512 (defun ange-ftp-parse-vms-filename ()
4513   (if (re-search-forward
4514          ange-ftp-vms-filename-regexp
4515          nil t)
4516         (buffer-substring (match-beginning 0) (match-end 0))))
4517
4518 ;; Parse the current buffer which is assumed to be in MultiNet FTP dir
4519 ;; format, and return a hashtable as the result.
4520 (defun ange-ftp-parse-vms-listing ()
4521   (let ((tbl (ange-ftp-make-hashtable))
4522         file)
4523     (goto-char (point-min))
4524     (ange-ftp-save-match-data
4525       (while (setq file (ange-ftp-parse-vms-filename))
4526         (if (string-match "\\.\\(DIR\\|dir\\);[0-9]+" file)
4527             ;; deal with directories
4528             (ange-ftp-put-hash-entry
4529              (substring file 0 (match-beginning 0)) t tbl)
4530           (ange-ftp-put-hash-entry file nil tbl)
4531           (if (string-match ";[0-9]+$" file) ; deal with extension
4532               ;; sans extension
4533               (ange-ftp-put-hash-entry
4534                (substring file 0 (match-beginning 0)) nil tbl)))
4535         (forward-line 1))
4536       ;; Would like to look for a "Total" line, or a "Directory" line to
4537       ;; make sure that the listing isn't complete garbage before putting
4538       ;; in "." and "..", but we can't even count on all VAX's giving us
4539       ;; either of these.
4540            (ange-ftp-put-hash-entry "." t tbl)
4541            (ange-ftp-put-hash-entry ".." t tbl))
4542     tbl))
4543
4544 (or (assq 'vms ange-ftp-parse-list-func-alist)
4545     (setq ange-ftp-parse-list-func-alist
4546           (cons '(vms . ange-ftp-parse-vms-listing)
4547                 ange-ftp-parse-list-func-alist)))
4548
4549 ;; This version only deletes file entries which have
4550 ;; explicit version numbers, because that is all VMS allows.
4551
4552 ;; Can the following two functions be speeded up using file
4553 ;; completion functions?
4554
4555 (defun ange-ftp-vms-delete-file-entry (name &optional dir-p)
4556   (if dir-p
4557       (ange-ftp-internal-delete-file-entry name t)
4558     (ange-ftp-save-match-data
4559       (let ((file (ange-ftp-get-file-part name)))
4560         (if (string-match ";[0-9]+$" file)
4561             ;; In VMS you can't delete a file without an explicit
4562             ;; version number, or wild-card (e.g. FOO;*)
4563             ;; For now, we give up on wildcards.
4564             (let ((files (ange-ftp-get-hash-entry
4565                           (file-name-directory name)
4566                           ange-ftp-files-hashtable)))
4567               (if files
4568                   (let* ((root (substring file 0
4569                                           (match-beginning 0)))
4570                          (regexp (concat "^"
4571                                          (regexp-quote root)
4572                                          ";[0-9]+$"))
4573                          versions)
4574                     (ange-ftp-del-hash-entry file files)
4575                     ;; Now we need to check if there are any
4576                     ;; versions left. If not, then delete the
4577                     ;; root entry.
4578                     (mapatoms
4579                      '(lambda (sym)
4580                         (and (string-match regexp (get sym 'key))
4581                              (setq versions t)))
4582                      files)
4583                     (or versions
4584                         (ange-ftp-del-hash-entry root files))))))))))
4585
4586 (or (assq 'vms ange-ftp-delete-file-entry-alist)
4587     (setq ange-ftp-delete-file-entry-alist
4588           (cons '(vms . ange-ftp-vms-delete-file-entry)
4589                 ange-ftp-delete-file-entry-alist)))
4590
4591 (defun ange-ftp-vms-add-file-entry (name &optional dir-p)
4592   (if dir-p
4593       (ange-ftp-internal-add-file-entry name t)
4594     (let ((files (ange-ftp-get-hash-entry
4595                   (file-name-directory name)
4596                   ange-ftp-files-hashtable)))
4597       (if files
4598           (let ((file (ange-ftp-get-file-part name)))
4599             (ange-ftp-save-match-data
4600               (if (string-match ";[0-9]+$" file)
4601                   (ange-ftp-put-hash-entry
4602                    (substring file 0 (match-beginning 0))
4603                    nil files)
4604                 ;; Need to figure out what version of the file
4605                 ;; is being added.
4606                 (let ((regexp (concat "^"
4607                                       (regexp-quote file)
4608                                       ";\\([0-9]+\\)$"))
4609                       (version 0))
4610                   (mapatoms
4611                    '(lambda (sym)
4612                       (let ((name (get sym 'key)))
4613                         (and (string-match regexp name)
4614                              (setq version
4615                                    (max version
4616                                         (string-to-int
4617                                          (substring name
4618                                                     (match-beginning 1)
4619                                                     (match-end 1))))))))
4620                    files)
4621                   (setq version (1+ version))
4622                   (ange-ftp-put-hash-entry
4623                    (concat file ";" (int-to-string version))
4624                    nil files))))
4625             (ange-ftp-put-hash-entry file nil files))))))
4626
4627 (or (assq 'vms ange-ftp-add-file-entry-alist)
4628     (setq ange-ftp-add-file-entry-alist
4629           (cons '(vms . ange-ftp-vms-add-file-entry)
4630                 ange-ftp-add-file-entry-alist)))
4631
4632
4633 (defun ange-ftp-add-vms-host (host)
4634   "Mark HOST as the name of a machine running VMS."
4635   (interactive
4636    (list (read-string "Host: "
4637                       (let ((name (or (buffer-file-name) default-directory)))
4638                         (and name (car (ange-ftp-ftp-name name)))))))
4639   (if (not (ange-ftp-vms-host host))
4640       (setq ange-ftp-vms-host-regexp
4641             (concat "^" (regexp-quote host) "$"
4642                     (and ange-ftp-vms-host-regexp "\\|")
4643                     ange-ftp-vms-host-regexp)
4644             ange-ftp-host-cache nil)))
4645
4646
4647 (defun ange-ftp-vms-file-name-as-directory (name)
4648   (ange-ftp-save-match-data
4649     (if (string-match "\\.\\(DIR\\|dir\\)\\(;[0-9]+\\)?$" name)
4650         (setq name (substring name 0 (match-beginning 0))))
4651     (ange-ftp-real-file-name-as-directory name)))
4652
4653 (or (assq 'vms ange-ftp-file-name-as-directory-alist)
4654     (setq ange-ftp-file-name-as-directory-alist
4655           (cons '(vms . ange-ftp-vms-file-name-as-directory)
4656                 ange-ftp-file-name-as-directory-alist)))
4657
4658 ;;; Tree dired support:
4659
4660 ;; For this code I have borrowed liberally from Sebastian Kremer's
4661 ;; dired-vms.el
4662
4663
4664 ;;;; These regexps must be anchored to beginning of line.
4665 ;;;; Beware that the ftpd may put the device in front of the filename.
4666
4667 ;;(defconst ange-ftp-dired-vms-re-exe "^. [^ \t.]+\\.\\(EXE\\|exe\\)[; ]"
4668 ;;  "Regular expression to use to search for VMS executable files.")
4669
4670 ;;(defconst ange-ftp-dired-vms-re-dir "^. [^ \t.]+\\.\\(DIR\\|dir\\)[; ]"
4671 ;;  "Regular expression to use to search for VMS directories.")
4672
4673 ;;(or (assq 'vms ange-ftp-dired-re-exe-alist)
4674 ;;    (setq ange-ftp-dired-re-exe-alist
4675 ;;        (cons (cons 'vms  ange-ftp-dired-vms-re-exe)
4676 ;;              ange-ftp-dired-re-exe-alist)))
4677
4678 ;;(or (assq 'vms ange-ftp-dired-re-dir-alist)
4679 ;;    (setq ange-ftp-dired-re-dir-alist
4680 ;;        (cons (cons 'vms  ange-ftp-dired-vms-re-dir)
4681 ;;              ange-ftp-dired-re-dir-alist)))
4682
4683 ;;(defun ange-ftp-dired-vms-insert-headerline (dir)
4684 ;;  ;; VMS inserts a headerline. I would prefer the headerline
4685 ;;  ;; to be in ange-ftp format. This version tries to
4686 ;;  ;; be careful, because we can't count on a headerline
4687 ;;  ;; over ftp, and we wouldn't want to delete anything
4688 ;;  ;; important.
4689 ;;  (save-excursion
4690 ;;    (if (looking-at "^  wildcard ")
4691 ;;      (forward-line 1))
4692 ;;    (if (looking-at "^[ \n\t]*[^\n]+\\][ \t]*\n")
4693 ;;      (delete-region (point) (match-end 0))))
4694 ;;  (ange-ftp-real-dired-insert-headerline dir))
4695
4696 ;;(or (assq 'vms ange-ftp-dired-insert-headerline-alist)
4697 ;;    (setq ange-ftp-dired-insert-headerline-alist
4698 ;;        (cons '(vms . ange-ftp-dired-vms-insert-headerline)
4699 ;;              ange-ftp-dired-insert-headerline-alist)))
4700
4701 ;;(defun ange-ftp-dired-vms-move-to-filename (&optional raise-error eol)
4702 ;;  "In dired, move to first char of filename on this line.
4703 ;;Returns position (point) or nil if no filename on this line."
4704 ;;  ;; This is the VMS version.
4705 ;;  (let (case-fold-search)
4706 ;;    (or eol (setq eol (progn (end-of-line) (point))))
4707 ;;    (beginning-of-line)
4708 ;;    (if (re-search-forward ange-ftp-vms-filename-regexp eol t)
4709 ;;      (goto-char (match-beginning 1))
4710 ;;      (if raise-error
4711 ;;        (error "No file on this line")
4712 ;;      nil))))
4713
4714 ;;(or (assq 'vms ange-ftp-dired-move-to-filename-alist)
4715 ;;    (setq ange-ftp-dired-move-to-filename-alist
4716 ;;        (cons '(vms . ange-ftp-dired-vms-move-to-filename)
4717 ;;              ange-ftp-dired-move-to-filename-alist)))
4718
4719 ;;(defun ange-ftp-dired-vms-move-to-end-of-filename (&optional no-error eol)
4720 ;;  ;; Assumes point is at beginning of filename.
4721 ;;  ;; So, it should be called only after (dired-move-to-filename t).
4722 ;;  ;; case-fold-search must be nil, at least for VMS.
4723 ;;  ;; On failure, signals an error or returns nil.
4724 ;;  ;; This is the VMS version.
4725 ;;  (let (opoint hidden case-fold-search)
4726 ;;    (setq opoint (point))
4727 ;;    (or eol (setq eol (save-excursion (end-of-line) (point))))
4728 ;;    (setq hidden (and selective-display
4729 ;;                    (save-excursion (search-forward "\r" eol t))))
4730 ;;    (if hidden
4731 ;;      nil
4732 ;;      (re-search-forward ange-ftp-vms-filename-regexp eol t))
4733 ;;    (or no-error
4734 ;;      (not (eq opoint (point)))
4735 ;;      (error
4736 ;;       (if hidden
4737 ;;           (substitute-command-keys
4738 ;;            "File line is hidden, type \\[dired-hide-subdir] to unhide")
4739 ;;         "No file on this line")))
4740 ;;    (if (eq opoint (point))
4741 ;;      nil
4742 ;;      (point))))
4743
4744 ;;(or (assq 'vms ange-ftp-dired-move-to-end-of-filename-alist)
4745 ;;    (setq ange-ftp-dired-move-to-end-of-filename-alist
4746 ;;        (cons '(vms . ange-ftp-dired-vms-move-to-end-of-filename)
4747 ;;              ange-ftp-dired-move-to-end-of-filename-alist)))
4748
4749 ;;(defun ange-ftp-dired-vms-between-files ()
4750 ;;  (save-excursion
4751 ;;    (beginning-of-line)
4752 ;;    (or (equal (following-char) 10) ; newline
4753 ;;     (equal (following-char) 9)     ; tab
4754 ;;     (progn (forward-char 2)
4755 ;;          (or (looking-at "Total of")
4756 ;;              (equal (following-char) 32))))))
4757
4758 ;;(or (assq 'vms ange-ftp-dired-between-files-alist)
4759 ;;    (setq ange-ftp-dired-between-files-alist
4760 ;;        (cons '(vms . ange-ftp-dired-vms-between-files)
4761 ;;              ange-ftp-dired-between-files-alist)))
4762
4763 ;; Beware! In VMS filenames must be of the form "FILE.TYPE".
4764 ;; Therefore, we cannot just append a ".Z" to filenames for
4765 ;; compressed files. Instead, we turn "FILE.TYPE" into
4766 ;; "FILE.TYPE-Z". Hope that this is a reasonable thing to do.
4767
4768 (defun ange-ftp-vms-make-compressed-filename (name &optional reverse)
4769   (cond
4770    ((string-match "-Z;[0-9]+$" name)
4771     (list nil (substring name 0 (match-beginning 0))))
4772    ((string-match ";[0-9]+$" name)
4773     (list nil (substring name 0 (match-beginning 0))))
4774    ((string-match "-Z$" name)
4775     (list nil (substring name 0 -2)))
4776    (t
4777     (list t
4778           (if (string-match ";[0-9]+$" name)
4779               (concat (substring name 0 (match-beginning 0))
4780                       "-Z")
4781             (concat name "-Z"))))))
4782
4783 (or (assq 'vms ange-ftp-make-compressed-filename-alist)
4784     (setq ange-ftp-make-compressed-filename-alist
4785           (cons '(vms . ange-ftp-vms-make-compressed-filename)
4786                 ange-ftp-make-compressed-filename-alist)))
4787
4788 ;;;; When the filename is too long, VMS will use two lines to list a file
4789 ;;;; (damn them!) This will confuse dired. To solve this, need to convince
4790 ;;;; Sebastian to use a function dired-go-to-end-of-file-line, instead of
4791 ;;;; (forward-line 1). This would require a number of changes to dired.el.
4792 ;;;; If dired gets confused, revert-buffer will fix it.
4793
4794 ;;(defun ange-ftp-dired-vms-ls-trim ()
4795 ;;  (goto-char (point-min))
4796 ;;  (let ((case-fold-search nil))
4797 ;;    (re-search-forward  ange-ftp-vms-filename-regexp))
4798 ;;  (beginning-of-line)
4799 ;;  (delete-region (point-min) (point))
4800 ;;  (forward-line 1)
4801 ;;  (delete-region (point) (point-max)))
4802
4803
4804 ;;(or (assq 'vms ange-ftp-dired-ls-trim-alist)
4805 ;;    (setq ange-ftp-dired-ls-trim-alist
4806 ;;        (cons '(vms . ange-ftp-dired-vms-ls-trim)
4807 ;;              ange-ftp-dired-ls-trim-alist)))
4808
4809 (defun ange-ftp-vms-sans-version (name)
4810   (ange-ftp-save-match-data
4811     (if (string-match ";[0-9]+$" name)
4812         (substring name 0 (match-beginning 0))
4813       name)))
4814
4815 (or (assq 'vms ange-ftp-sans-version-alist)
4816     (setq ange-ftp-sans-version-alist
4817           (cons '(vms . ange-ftp-vms-sans-version)
4818                 ange-ftp-sans-version-alist)))
4819
4820 ;;(defvar ange-ftp-file-version-alist)
4821
4822 ;;;;; The vms version of clean-directory has 2 more optional args
4823 ;;;;; than the usual dired version. This is so that it can be used by
4824 ;;;;; ange-ftp-dired-vms-flag-backup-files.
4825
4826 ;;(defun ange-ftp-dired-vms-clean-directory (keep &optional marker msg)
4827 ;;  "Flag numerical backups for deletion.
4828 ;;Spares `dired-kept-versions' latest versions, and `kept-old-versions' oldest.
4829 ;;Positive prefix arg KEEP overrides `dired-kept-versions';
4830 ;;Negative prefix arg KEEP overrides `kept-old-versions' with KEEP made positive.
4831
4832 ;;To clear the flags on these files, you can use \\[dired-flag-backup-files]
4833 ;;with a prefix argument."
4834 ;;;  (interactive "P") ; Never actually called interactively.
4835 ;;  (setq keep (max 1 (if keep (prefix-numeric-value keep) dired-kept-versions)))
4836 ;;  (let ((early-retention (if (< keep 0) (- keep) kept-old-versions))
4837 ;;      ;; late-retention must NEVER be allowed to be less than 1 in VMS!
4838 ;;      ;; This could wipe ALL copies of the file.
4839 ;;      (late-retention (max 1 (if (<= keep 0) dired-kept-versions keep)))
4840 ;;      (action (or msg "Cleaning"))
4841 ;;      (ange-ftp-trample-marker (or marker dired-del-marker))
4842 ;;      (ange-ftp-file-version-alist ()))
4843 ;;    (message (concat action
4844 ;;                   " numerical backups (keeping %d late, %d old)...")
4845 ;;           late-retention early-retention)
4846 ;;    ;; Look at each file.
4847 ;;    ;; If the file has numeric backup versions,
4848 ;;    ;; put on ange-ftp-file-version-alist an element of the form
4849 ;;    ;; (FILENAME . VERSION-NUMBER-LIST)
4850 ;;    (dired-map-dired-file-lines (function
4851 ;;                               ange-ftp-dired-vms-collect-file-versions))
4852 ;;    ;; Sort each VERSION-NUMBER-LIST,
4853 ;;    ;; and remove the versions not to be deleted.
4854 ;;    (let ((fval ange-ftp-file-version-alist))
4855 ;;      (while fval
4856 ;;      (let* ((sorted-v-list (cons 'q (sort (cdr (car fval)) '<)))
4857 ;;             (v-count (length sorted-v-list)))
4858 ;;        (if (> v-count (+ early-retention late-retention))
4859 ;;            (rplacd (nthcdr early-retention sorted-v-list)
4860 ;;                    (nthcdr (- v-count late-retention)
4861 ;;                            sorted-v-list)))
4862 ;;        (rplacd (car fval)
4863 ;;                (cdr sorted-v-list)))
4864 ;;      (setq fval (cdr fval))))
4865 ;;    ;; Look at each file.  If it is a numeric backup file,
4866 ;;    ;; find it in a VERSION-NUMBER-LIST and maybe flag it for deletion.
4867 ;;    (dired-map-dired-file-lines
4868 ;;     (function
4869 ;;      ange-ftp-dired-vms-trample-file-versions mark))
4870 ;;    (message (concat action " numerical backups...done"))))
4871
4872 ;;(or (assq 'vms ange-ftp-dired-clean-directory-alist)
4873 ;;    (setq ange-ftp-dired-clean-directory-alist
4874 ;;        (cons '(vms . ange-ftp-dired-vms-clean-directory)
4875 ;;              ange-ftp-dired-clean-directory-alist)))
4876
4877 ;;(defun ange-ftp-dired-vms-collect-file-versions (fn)
4878 ;;  ;;  "If it looks like file FN has versions, return a list of the versions.
4879 ;;  ;;That is a list of strings which are file names.
4880 ;;  ;;The caller may want to flag some of these files for deletion."
4881 ;;(let ((name (nth 2 (ange-ftp-ftp-name fn))))
4882 ;;  (if (string-match ";[0-9]+$" name)
4883 ;;      (let* ((name (substring name 0 (match-beginning 0)))
4884 ;;           (fn (ange-ftp-replace-name-component fn name)))
4885 ;;      (if (not (assq fn ange-ftp-file-version-alist))
4886 ;;          (let* ((base-versions
4887 ;;                  (concat (file-name-nondirectory name) ";"))
4888 ;;                 (bv-length (length base-versions))
4889 ;;                 (possibilities (file-name-all-completions
4890 ;;                                 base-versions
4891 ;;                                 (file-name-directory fn)))
4892 ;;                 (versions (mapcar
4893 ;;                            '(lambda (arg)
4894 ;;                               (if (and (string-match
4895 ;;                                         "[0-9]+$" arg bv-length)
4896 ;;                                        (= (match-beginning 0) bv-length))
4897 ;;                                   (string-to-int (substring arg bv-length))
4898 ;;                                 0))
4899 ;;                            possibilities)))
4900 ;;            (if versions
4901 ;;                (setq
4902 ;;                 ange-ftp-file-version-alist
4903 ;;                 (cons (cons fn versions)
4904 ;;                       ange-ftp-file-version-alist)))))))))
4905
4906 ;;(defun ange-ftp-dired-vms-trample-file-versions (fn)
4907 ;;  (let* ((start-vn (string-match ";[0-9]+$" fn))
4908 ;;       base-version-list)
4909 ;;    (and start-vn
4910 ;;       (setq base-version-list        ; there was a base version to which
4911 ;;             (assoc (substring fn 0 start-vn) ; this looks like a
4912 ;;                    ange-ftp-file-version-alist))     ; subversion
4913 ;;       (not (memq (string-to-int (substring fn (1+ start-vn)))
4914 ;;                  base-version-list)) ; this one doesn't make the cut
4915 ;;       (progn (beginning-of-line)
4916 ;;              (delete-char 1)
4917 ;;              (insert ange-ftp-trample-marker)))))
4918
4919 ;;(defun ange-ftp-dired-vms-flag-backup-files (&optional unflag-p)
4920 ;;  (let ((dired-kept-versions 1)
4921 ;;      (kept-old-versions 0)
4922 ;;      marker msg)
4923 ;;    (if unflag-p
4924 ;;      (setq marker ?\040 msg "Unflagging")
4925 ;;      (setq marker dired-del-marker msg "Cleaning"))
4926 ;;    (ange-ftp-dired-vms-clean-directory nil marker msg)))
4927
4928 ;;(or (assq 'vms ange-ftp-dired-flag-backup-files-alist)
4929 ;;    (setq ange-ftp-dired-flag-backup-files-alist
4930 ;;        (cons '(vms . ange-ftp-dired-vms-flag-backup-files)
4931 ;;              ange-ftp-dired-flag-backup-files-alist)))
4932
4933 ;;(defun ange-ftp-dired-vms-backup-diff (&optional switches)
4934 ;;  (let ((file (dired-get-filename 'no-dir))
4935 ;;      bak)
4936 ;;    (if (and (string-match ";[0-9]+$" file)
4937 ;;           ;; Find most recent previous version.
4938 ;;           (let ((root (substring file 0 (match-beginning 0)))
4939 ;;                 (ver
4940 ;;                  (string-to-int (substring file (1+ (match-beginning 0)))))
4941 ;;                 found)
4942 ;;             (setq ver (1- ver))
4943 ;;             (while (and (> ver 0) (not found))
4944 ;;               (setq bak (concat root ";" (int-to-string ver)))
4945 ;;               (and (file-exists-p bak) (setq found t))
4946 ;;               (setq ver (1- ver)))
4947 ;;             found))
4948 ;;      (if switches
4949 ;;          (diff (expand-file-name bak) (expand-file-name file) switches)
4950 ;;        (diff (expand-file-name bak) (expand-file-name file)))
4951 ;;      (error "No previous version found for %s" file))))
4952
4953 ;;(or (assq 'vms ange-ftp-dired-backup-diff-alist)
4954 ;;    (setq ange-ftp-dired-backup-diff-alist
4955 ;;        (cons '(vms . ange-ftp-dired-vms-backup-diff)
4956 ;;              ange-ftp-dired-backup-diff-alist)))
4957
4958 \f
4959 ;;;; ------------------------------------------------------------
4960 ;;;; MTS support
4961 ;;;; ------------------------------------------------------------
4962
4963
4964 ;; Convert NAME from UNIX-ish to MTS. If REVERSE given then convert from
4965 ;; MTS to UNIX-ish.
4966 (defun ange-ftp-fix-name-for-mts (name &optional reverse)
4967   (ange-ftp-save-match-data
4968     (if reverse
4969         (if (string-match "^\\([^:]+:\\)?\\(.*\\)$" name)
4970             (let (acct file)
4971               (if (match-beginning 1)
4972                   (setq acct (substring name 0 (match-end 1))))
4973               (if (match-beginning 2)
4974                   (setq file (substring name
4975                                         (match-beginning 2) (match-end 2))))
4976               (concat (and acct (concat "/" acct "/"))
4977                       file))
4978           (error "name %s didn't match" name))
4979       (if (string-match "^/\\([^:]+:\\)/\\(.*\\)$" name)
4980           (concat (substring name 1 (match-end 1))
4981                   (substring name (match-beginning 2) (match-end 2)))
4982         ;; Let's hope that mts will recognize it anyway.
4983         name))))
4984
4985 (or (assq 'mts ange-ftp-fix-name-func-alist)
4986     (setq ange-ftp-fix-name-func-alist
4987           (cons '(mts . ange-ftp-fix-name-for-mts)
4988                 ange-ftp-fix-name-func-alist)))
4989
4990 ;; Convert name from UNIX-ish to MTS ready for a DIRectory listing.
4991 ;; Remember that there are no directories in MTS.
4992 (defun ange-ftp-fix-dir-name-for-mts (dir-name)
4993   (if (string-equal dir-name "/")
4994       (error "Cannot get listing for fictitious \"/\" directory.")
4995     (let ((dir-name (ange-ftp-fix-name-for-mts dir-name)))
4996       (cond
4997        ((string-equal dir-name "")
4998         "?")
4999        ((string-match ":$" dir-name)
5000         (concat dir-name "?"))
5001        (dir-name))))) ; It's just a single file.
5002
5003 (or (assq 'mts ange-ftp-fix-dir-name-func-alist)
5004     (setq ange-ftp-fix-dir-name-func-alist
5005           (cons '(mts . ange-ftp-fix-dir-name-for-mts)
5006                 ange-ftp-fix-dir-name-func-alist)))
5007
5008 (or (memq 'mts ange-ftp-dumb-host-types)
5009     (setq ange-ftp-dumb-host-types
5010           (cons 'mts ange-ftp-dumb-host-types)))
5011
5012 (defvar ange-ftp-mts-host-regexp nil)
5013
5014 ;; Return non-nil if HOST is running MTS.
5015 (defun ange-ftp-mts-host (host)
5016   (and ange-ftp-mts-host-regexp
5017        (ange-ftp-save-match-data
5018          (string-match ange-ftp-mts-host-regexp host))))
5019
5020 ;; Parse the current buffer which is assumed to be in mts ftp dir format.
5021 (defun ange-ftp-parse-mts-listing ()
5022   (let ((tbl (ange-ftp-make-hashtable)))
5023     (goto-char (point-min))
5024     (ange-ftp-save-match-data
5025       (while (re-search-forward ange-ftp-date-regexp nil t)
5026         (end-of-line)
5027         (skip-chars-backward " ")
5028         (let ((end (point)))
5029           (skip-chars-backward "-A-Z0-9_.!")
5030           (ange-ftp-put-hash-entry (buffer-substring (point) end) nil tbl))
5031         (forward-line 1)))
5032       ;; Don't need to bother with ..
5033     (ange-ftp-put-hash-entry "." t tbl)
5034     tbl))
5035
5036 (or (assq 'mts ange-ftp-parse-list-func-alist)
5037     (setq ange-ftp-parse-list-func-alist
5038           (cons '(mts . ange-ftp-parse-mts-listing)
5039                 ange-ftp-parse-list-func-alist)))
5040
5041 (defun ange-ftp-add-mts-host (host)
5042   "Mark HOST as the name of a machine running MTS."
5043   (interactive
5044    (list (read-string "Host: "
5045                       (let ((name (or (buffer-file-name) default-directory)))
5046                         (and name (car (ange-ftp-ftp-name name)))))))
5047   (if (not (ange-ftp-mts-host host))
5048       (setq ange-ftp-mts-host-regexp
5049             (concat "^" (regexp-quote host) "$"
5050                     (and ange-ftp-mts-host-regexp "\\|")
5051                     ange-ftp-mts-host-regexp)
5052             ange-ftp-host-cache nil)))
5053
5054 ;;; Tree dired support:
5055
5056 ;;;; There aren't too many systems left that use MTS. This dired support will
5057 ;;;; work for the implementation of ftp on mtsg.ubc.ca. I hope other mts systems
5058 ;;;; implement ftp in the same way. If not, it might be necessary to make the
5059 ;;;; following more flexible.
5060
5061 ;;(defun ange-ftp-dired-mts-move-to-filename (&optional raise-error eol)
5062 ;;  "In dired, move to first char of filename on this line.
5063 ;;Returns position (point) or nil if no filename on this line."
5064 ;;  ;; This is the MTS version.
5065 ;;  (or eol (setq eol (progn (end-of-line) (point))))
5066 ;;  (beginning-of-line)
5067 ;;  (if (re-search-forward
5068 ;;       ange-ftp-date-regexp eol t)
5069 ;;      (progn
5070 ;;      (skip-chars-forward " ")          ; Eat blanks after date
5071 ;;      (skip-chars-forward "0-9:" eol)   ; Eat time or year
5072 ;;      (skip-chars-forward " " eol)      ; one space before filename
5073 ;;      ;; When listing an account other than the users own account it appends
5074 ;;      ;; ACCT: to the beginning of the filename. Skip over this.
5075 ;;      (and (looking-at "[A-Z0-9_.]+:")
5076 ;;           (goto-char (match-end 0)))
5077 ;;      (point))
5078 ;;    (if raise-error
5079 ;;      (error "No file on this line")
5080 ;;      nil)))
5081
5082 ;;(or (assq 'mts ange-ftp-dired-move-to-filename-alist)
5083 ;;    (setq ange-ftp-dired-move-to-filename-alist
5084 ;;        (cons '(mts . ange-ftp-dired-mts-move-to-filename)
5085 ;;              ange-ftp-dired-move-to-filename-alist)))
5086
5087 ;;(defun ange-ftp-dired-mts-move-to-end-of-filename (&optional no-error eol)
5088 ;;  ;; Assumes point is at beginning of filename.
5089 ;;  ;; So, it should be called only after (dired-move-to-filename t).
5090 ;;  ;; On failure, signals an error or returns nil.
5091 ;;  ;; This is the MTS version.
5092 ;;  (let (opoint hidden case-fold-search)
5093 ;;    (setq opoint (point)
5094 ;;        eol (save-excursion (end-of-line) (point))
5095 ;;        hidden (and selective-display
5096 ;;                    (save-excursion (search-forward "\r" eol t))))
5097 ;;    (if hidden
5098 ;;      nil
5099 ;;      (skip-chars-forward "-A-Z0-9._!" eol))
5100 ;;    (or no-error
5101 ;;      (not (eq opoint (point)))
5102 ;;      (error
5103 ;;       (if hidden
5104 ;;           (substitute-command-keys
5105 ;;            "File line is hidden, type \\[dired-hide-subdir] to unhide")
5106 ;;         "No file on this line")))
5107 ;;    (if (eq opoint (point))
5108 ;;      nil
5109 ;;      (point))))
5110
5111 ;;(or (assq 'mts ange-ftp-dired-move-to-end-of-filename-alist)
5112 ;;    (setq ange-ftp-dired-move-to-end-of-filename-alist
5113 ;;        (cons '(mts . ange-ftp-dired-mts-move-to-end-of-filename)
5114 ;;              ange-ftp-dired-move-to-end-of-filename-alist)))
5115 \f
5116 ;;;; ------------------------------------------------------------
5117 ;;;; CMS support
5118 ;;;; ------------------------------------------------------------
5119
5120 ;; Since CMS doesn't have any full file name syntax, we have to fudge
5121 ;; things with cd's. We actually send too many cd's, but it's dangerous
5122 ;; to try to remember the current minidisk, because if the connection
5123 ;; is closed and needs to be reopened, we will find ourselves back in
5124 ;; the default minidisk. This is fairly likely since CMS ftp servers
5125 ;; usually close the connection after 5 minutes of inactivity.
5126
5127 ;; Have I got the filename character set right?
5128
5129 (defun ange-ftp-fix-name-for-cms (name &optional reverse)
5130   (ange-ftp-save-match-data
5131     (if reverse
5132         ;; Since we only convert output from a pwd in this direction,
5133         ;; we'll assume that it's a minidisk, and make it into a
5134         ;; directory file name. Note that the expand-dir-hashtable
5135         ;; stores directories without the trailing /. Is this
5136         ;; consistent?
5137         (concat "/" name)
5138       (if (string-match "^/\\([-A-Z0-9$*._]+\\)/\\([-A-Z0-9$._]+\\)?$"
5139                         name)
5140           (let ((minidisk (substring name 1 (match-end 1))))
5141             (if (match-beginning 2)
5142                 (let ((file (substring name (match-beginning 2)
5143                                        (match-end 2)))
5144                       (cmd (concat "cd " minidisk))
5145
5146                       ;; Note that host and user are bound in the call
5147                       ;; to ange-ftp-send-cmd
5148                       (proc (ange-ftp-get-process ange-ftp-this-host
5149                                                   ange-ftp-this-user)))
5150
5151                   ;; Must use ange-ftp-raw-send-cmd here to avoid
5152                   ;; an infinite loop.
5153                   (if (car (ange-ftp-raw-send-cmd proc cmd ange-ftp-this-msg))
5154                       file
5155                     ;; failed... try ONCE more.
5156                     (setq proc (ange-ftp-get-process ange-ftp-this-host
5157                                                      ange-ftp-this-user))
5158                     (let ((result (ange-ftp-raw-send-cmd proc cmd
5159                                                          ange-ftp-this-msg)))
5160                       (if (car result)
5161                           file
5162                         ;; failed.  give up.
5163                         (ange-ftp-error ange-ftp-this-host ange-ftp-this-user
5164                                         (format "cd to minidisk %s failed: %s"
5165                                                 minidisk (cdr result)))))))
5166               ;; return the minidisk
5167               minidisk))
5168         (error "Invalid CMS filename")))))
5169
5170 (or (assq 'cms ange-ftp-fix-name-func-alist)
5171     (setq ange-ftp-fix-name-func-alist
5172           (cons '(cms . ange-ftp-fix-name-for-cms)
5173                 ange-ftp-fix-name-func-alist)))
5174
5175 (or (memq 'cms ange-ftp-dumb-host-types)
5176     (setq ange-ftp-dumb-host-types
5177           (cons 'cms ange-ftp-dumb-host-types)))
5178
5179 ;; Convert name from UNIX-ish to CMS ready for a DIRectory listing.
5180 (defun ange-ftp-fix-dir-name-for-cms (dir-name)
5181   (cond
5182    ((string-equal "/" dir-name)
5183     (error "Cannot get listing for fictitious \"/\" directory."))
5184    ((string-match "^/\\([-A-Z0-9$*._]+\\)/\\([-A-Z0-9$._]+\\)?$" dir-name)
5185     (let* ((minidisk (substring dir-name (match-beginning 1) (match-end 1)))
5186            ;; host and user are bound in the call to ange-ftp-send-cmd
5187            (proc (ange-ftp-get-process ange-ftp-this-host ange-ftp-this-user))
5188            (cmd (concat "cd " minidisk))
5189            (file (if (match-beginning 2)
5190                      ;; it's a single file
5191                      (substring dir-name (match-beginning 2)
5192                                 (match-end 2))
5193                    ;; use the wild-card
5194                    "*")))
5195       (if (car (ange-ftp-raw-send-cmd proc cmd))
5196           file
5197         ;; try again...
5198         (setq proc (ange-ftp-get-process ange-ftp-this-host
5199                                          ange-ftp-this-user))
5200         (let ((result (ange-ftp-raw-send-cmd proc cmd)))
5201           (if (car result)
5202               file
5203             ;; give up
5204             (ange-ftp-error ange-ftp-this-host ange-ftp-this-user
5205                             (format "cd to minidisk %s failed: "
5206                                     minidisk (cdr result))))))))
5207    (t (error "Invalid CMS file name"))))
5208
5209 (or (assq 'cms ange-ftp-fix-dir-name-func-alist)
5210     (setq ange-ftp-fix-dir-name-func-alist
5211           (cons '(cms . ange-ftp-fix-dir-name-for-cms)
5212                 ange-ftp-fix-dir-name-func-alist)))
5213
5214 (defvar ange-ftp-cms-host-regexp nil
5215   "Regular expression to match hosts running the CMS operating system.")
5216
5217 ;; Return non-nil if HOST is running CMS.
5218 (defun ange-ftp-cms-host (host)
5219   (and ange-ftp-cms-host-regexp
5220        (ange-ftp-save-match-data
5221          (string-match ange-ftp-cms-host-regexp host))))
5222
5223 (defun ange-ftp-add-cms-host (host)
5224   "Mark HOST as the name of a CMS host."
5225   (interactive
5226    (list (read-string "Host: "
5227                       (let ((name (or (buffer-file-name) default-directory)))
5228                         (and name (car (ange-ftp-ftp-name name)))))))
5229   (if (not (ange-ftp-cms-host host))
5230       (setq ange-ftp-cms-host-regexp
5231             (concat "^" (regexp-quote host) "$"
5232                     (and ange-ftp-cms-host-regexp "\\|")
5233                     ange-ftp-cms-host-regexp)
5234             ange-ftp-host-cache nil)))
5235
5236 (defun ange-ftp-parse-cms-listing ()
5237   ;; Parse the current buffer which is assumed to be a CMS directory listing.
5238   ;; If we succeed in getting a listing, then we will assume that the minidisk
5239   ;; exists. file is bound by the call to ange-ftp-ls. This doesn't work
5240   ;; because ange-ftp doesn't know that the root hashtable has only part of
5241   ;; the info. It will assume that if a minidisk isn't in it, then it doesn't
5242   ;; exist. It would be nice if completion worked for minidisks, as we
5243   ;; discover them.
5244 ;  (let* ((dir-file (directory-file-name file))
5245 ;        (root (file-name-directory dir-file))
5246 ;        (minidisk (ange-ftp-get-file-part dir-file))
5247 ;        (root-tbl (ange-ftp-get-hash-entry root ange-ftp-files-hashtable)))
5248 ;    (if root-tbl
5249 ;       (ange-ftp-put-hash-entry minidisk t root-tbl)
5250 ;      (setq root-tbl (ange-ftp-make-hashtable))
5251 ;      (ange-ftp-put-hash-entry minidisk t root-tbl)
5252 ;      (ange-ftp-put-hash-entry "." t root-tbl)
5253 ;      (ange-ftp-set-files root root-tbl)))
5254   ;; Now do the usual parsing
5255   (let ((tbl (ange-ftp-make-hashtable)))
5256     (goto-char (point-min))
5257     (ange-ftp-save-match-data
5258       (while
5259           (re-search-forward
5260            "^\\([-A-Z0-9$_]+\\) +\\([-A-Z0-9$_]+\\) +[VF] +[0-9]+ " nil t)
5261         (ange-ftp-put-hash-entry
5262          (concat (buffer-substring (match-beginning 1)
5263                                    (match-end 1))
5264                  "."
5265                  (buffer-substring (match-beginning 2)
5266                                    (match-end 2)))
5267          nil tbl)
5268         (forward-line 1))
5269       (ange-ftp-put-hash-entry "." t tbl))
5270     tbl))
5271
5272 (or (assq 'cms ange-ftp-parse-list-func-alist)
5273     (setq ange-ftp-parse-list-func-alist
5274           (cons '(cms . ange-ftp-parse-cms-listing)
5275                 ange-ftp-parse-list-func-alist)))
5276
5277 ;;;;; Tree dired support:
5278
5279 ;;(defconst ange-ftp-dired-cms-re-exe
5280 ;;  "^. [-A-Z0-9$_]+ +EXEC "
5281 ;;  "Regular expression to use to search for CMS executables.")
5282
5283 ;;(or (assq 'cms ange-ftp-dired-re-exe-alist)
5284 ;;    (setq ange-ftp-dired-re-exe-alist
5285 ;;        (cons (cons 'cms  ange-ftp-dired-cms-re-exe)
5286 ;;              ange-ftp-dired-re-exe-alist)))
5287
5288
5289 ;;(defun ange-ftp-dired-cms-insert-headerline (dir)
5290 ;;  ;; CMS has no total line, so we insert a blank line for
5291 ;;  ;; aesthetics.
5292 ;;  (insert "\n")
5293 ;;  (forward-char -1)
5294 ;;  (ange-ftp-real-dired-insert-headerline dir))
5295
5296 ;;(or (assq 'cms ange-ftp-dired-insert-headerline-alist)
5297 ;;    (setq ange-ftp-dired-insert-headerline-alist
5298 ;;        (cons '(cms . ange-ftp-dired-cms-insert-headerline)
5299 ;;              ange-ftp-dired-insert-headerline-alist)))
5300
5301 ;;(defun ange-ftp-dired-cms-move-to-filename (&optional raise-error eol)
5302 ;;  "In dired, move to the first char of filename on this line."
5303 ;;  ;; This is the CMS version.
5304 ;;  (or eol (setq eol (progn (end-of-line) (point))))
5305 ;;  (let (case-fold-search)
5306 ;;    (beginning-of-line)
5307 ;;    (if (re-search-forward " [-A-Z0-9$_]+ +[-A-Z0-9$_]+ +[VF] +[0-9]+ " eol t)
5308 ;;      (goto-char (1+ (match-beginning 0)))
5309 ;;      (if raise-error
5310 ;;        (error "No file on this line")
5311 ;;      nil))))
5312
5313 ;;(or (assq 'cms ange-ftp-dired-move-to-filename-alist)
5314 ;;    (setq ange-ftp-dired-move-to-filename-alist
5315 ;;        (cons '(cms . ange-ftp-dired-cms-move-to-filename)
5316 ;;              ange-ftp-dired-move-to-filename-alist)))
5317
5318 ;;(defun ange-ftp-dired-cms-move-to-end-of-filename (&optional no-error eol)
5319 ;;  ;; Assumes point is at beginning of filename.
5320 ;;  ;; So, it should be called only after (dired-move-to-filename t).
5321 ;;  ;; case-fold-search must be nil, at least for VMS.
5322 ;;  ;; On failure, signals an error or returns nil.
5323 ;;  ;; This is the CMS version.
5324 ;;  (let ((opoint (point))
5325 ;;      case-fold-search hidden)
5326 ;;    (or eol (setq eol (save-excursion (end-of-line) (point))))
5327 ;;    (setq hidden (and selective-display
5328 ;;                    (save-excursion
5329 ;;                      (search-forward "\r" eol t))))
5330 ;;    (if hidden
5331 ;;      (if no-error
5332 ;;          nil
5333 ;;        (error
5334 ;;         (substitute-command-keys
5335 ;;          "File line is hidden, type \\[dired-hide-subdir] to unhide")))
5336 ;;      (skip-chars-forward "-A-Z0-9$_" eol)
5337 ;;      (skip-chars-forward " " eol)
5338 ;;      (skip-chars-forward "-A-Z0-9$_" eol)
5339 ;;      (if (eq opoint (point))
5340 ;;        (if no-error
5341 ;;            nil
5342 ;;          (error "No file on this line"))
5343 ;;      (point)))))
5344
5345 ;;(or (assq 'cms ange-ftp-dired-move-to-end-of-filename-alist)
5346 ;;    (setq ange-ftp-dired-move-to-end-of-filename-alist
5347 ;;        (cons '(cms . ange-ftp-dired-cms-move-to-end-of-filename)
5348 ;;              ange-ftp-dired-move-to-end-of-filename-alist)))
5349
5350 (defun ange-ftp-cms-make-compressed-filename (name &optional reverse)
5351   (if (string-match "-Z$" name)
5352       (list nil (substring name 0 -2))
5353     (list t (concat name "-Z"))))
5354
5355 (or (assq 'cms ange-ftp-make-compressed-filename-alist)
5356     (setq ange-ftp-make-compressed-filename-alist
5357           (cons '(cms . ange-ftp-cms-make-compressed-filename)
5358                 ange-ftp-make-compressed-filename-alist)))
5359
5360 ;;(defun ange-ftp-dired-cms-get-filename (&optional localp no-error-if-not-filep)
5361 ;;  (let ((name (ange-ftp-real-dired-get-filename localp no-error-if-not-filep)))
5362 ;;    (and name
5363 ;;       (if (string-match "^\\([^ ]+\\) +\\([^ ]+\\)$" name)
5364 ;;           (concat (substring name 0 (match-end 1))
5365 ;;                   "."
5366 ;;                   (substring name (match-beginning 2) (match-end 2)))
5367 ;;         name))))
5368
5369 ;;(or (assq 'cms ange-ftp-dired-get-filename-alist)
5370 ;;    (setq ange-ftp-dired-get-filename-alist
5371 ;;        (cons '(cms . ange-ftp-dired-cms-get-filename)
5372 ;;              ange-ftp-dired-get-filename-alist)))
5373 \f
5374 ;;;; ------------------------------------------------------------
5375 ;;;; Finally provide package.
5376 ;;;; ------------------------------------------------------------
5377
5378 (provide 'ange-ftp)
5379
5380 ;;; ange-ftp.el ends here