lisp/ange-ftp.el

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