(bookmark-write): Add numbered backups for bookmark file.
[emacs.git] / lisp / ange-ftp.el
blobeb6e77cb07c10b377768493b977b6ef3c9570281
1 ;;; ange-ftp.el --- transparent FTP support for GNU Emacs
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.
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.
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.
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.
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.
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.
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.
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.
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.
99 ;;; Binary file transfers:
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.
105 ;;; Account passwords:
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.
114 ;;; Preloading:
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.
120 ;;; Status reports:
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.
129 ;;; Gateways:
131 ;;; Sometimes it is necessary for the FTP process to be run on a different
132 ;;; machine than the machine running GNU Emacs. This can happen when the
133 ;;; local machine has restrictions on what hosts it can access.
135 ;;; ange-ftp has support for running the ftp process on a different (gateway)
136 ;;; machine. The way it works is as follows:
138 ;;; 1) Set the variable 'ange-ftp-gateway-host' to the name of a machine
139 ;;; that doesn't have the access restrictions.
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:
146 ;;; "\\.hp\\.com$\\|^[^.]*$"
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.
152 ;;; 3) Using NFS and symlinks, make sure that there is a shared directory with
153 ;;; the *same* name between the local machine and the gateway machine.
154 ;;; This directory is necessary for temporary files created by ange-ftp.
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:
159 ;;; "/nfs/hplose/ange/ange-ftp"
161 ;;; where /nfs/hplose/ange is a directory that is shared between the
162 ;;; gateway machine and the local machine.
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.
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.
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.
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.
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.
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:
191 ;;; "^$*$ *"
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.
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:
202 ;;; "stty -onlcr -echo"
204 ;;; will work on HP-UX machines, whereas:
206 ;;; "stty -echo nl"
208 ;;; appears to work for some Sun machines.
210 ;;; That's all there is to it.
212 ;;; Smart gateways:
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.
218 ;;; Tips for using ange-ftp:
220 ;;; 1. For dired to work on a host which marks symlinks with a trailing @ in
221 ;;; an ls -alF listing, you need to (setq dired-ls-F-marks-symlinks t).
222 ;;; Most UNIX systems do not do this, but ULTRIX does. If you think that
223 ;;; there is a chance you might connect to an ULTRIX machine (such as
224 ;;; prep.ai.mit.edu), then set this variable accordingly. This will have
225 ;;; the side effect that dired will have problems with symlinks whose names
226 ;;; end in an @. If you get yourself into this situation then editing
227 ;;; dired's ls-switches to remove "F", will temporarily fix things.
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.
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.
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.
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?
262 ;;; ---------------------------------------------------------------------
263 ;;; Non-UNIX support:
264 ;;; ---------------------------------------------------------------------
266 ;;; VMS support:
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.
275 ;;; Filename Syntax:
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
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.
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 $$.
319 ;;; MTS support:
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.
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.
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:
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.
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.
375 ;;; ------------------------------------------------------------------
376 ;;; Bugs:
377 ;;; ------------------------------------------------------------------
378 ;;;
379 ;;; 1. Umask problems:
380 ;;; Be warned that files created by using ange-ftp will take account of the
381 ;;; umask of the ftp daemon process rather than the umask of the creating
382 ;;; user. This is particularly important when logging in as the root user.
383 ;;; The way that I tighten up the ftp daemon's umask under HP-UX is to make
384 ;;; sure that the umask is changed to 027 before I spawn /etc/inetd. I
385 ;;; suspect that there is something similar on other systems.
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.
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.
402 ;;; 4. Null (blank) passwords confuse both ange-ftp and some FTP daemons.
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.
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.
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?
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?
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.
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.
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.
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.
467 ;;; ange-ftp-lovers:
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.
474 ;;; To [un]subscribe to ange-ftp-lovers, or to report mailer problems with the
475 ;;; list, please mail one of the following addresses:
477 ;;; ange-ftp-lovers-request@anorman.hpl.hp.com
478 ;;; or
479 ;;; ange-ftp-lovers-request%anorman.hpl.hp.com@hplb.hpl.hp.com
481 ;;; Please don't forget the -request part.
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
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.
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
503 ;;; The archives for ange-ftp-lovers can be found via anonymous ftp under:
505 ;;; ftp.reed.edu:pub/mailing-lists/ange-ftp/
507 ;;; -----------------------------------------------------------
508 ;;; Technical information on this package:
509 ;;; -----------------------------------------------------------
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.
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)
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
531 ;;; Variables:
533 ;;; ange-ftp-TYPE-host-regexp
534 ;;; May need to add TYPE to ange-ftp-dumb-host-types
536 ;;; Check the following functions for OS dependent coding:
538 ;;; ange-ftp-host-type
539 ;;; ange-ftp-guess-host-type
540 ;;; ange-ftp-allow-child-lookup
542 ;;; Host type conventions:
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.
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.
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.
557 ;;; 'type = a remote host of TYPE type.
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.
564 ;;; Bug report codes:
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
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.
583 ;;; Thanks to Jamie Zawinski for bugfixes and for ideas such as gateways.
585 ;;; Thanks to Ken Laprade for improved .netrc parsing, password reading, and
586 ;;; dired / shell auto-loading.
588 ;;; Thanks to Sebastian Kremer for dired support and for many ideas and
589 ;;; bugfixes.
591 ;;; Thanks to Joe Wells for bugfixes, the original non-UNIX system support,
592 ;;; VOS support, and hostname completion.
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.
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.
602 ;;; Thanks to Dave Smith who wrote the info file for ange-ftp.
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.
613 ;;; Code:
614 (require 'comint)
616 ;;;; ------------------------------------------------------------
617 ;;;; User customization variables.
618 ;;;; ------------------------------------------------------------
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).")
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.
632 (defvar ange-ftp-multi-msgs
633 "^220-\\|^230-\\|^226\\|^25.-\\|^221-\\|^200-\\|^331-\\|^4[25]1-\\|^530-"
634 "*Regular expression matching messages from the ftp process that start
635 a multiline reply.")
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.")
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.
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.")
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.")
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.")
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.")
671 (defvar ange-ftp-tmp-name-template "/tmp/ange-ftp"
672 "*Template used to create temporary files.")
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.")
681 (defvar ange-ftp-netrc-filename "~/.netrc"
682 "*File in .netrc format to search for passwords.")
684 (defvar ange-ftp-disable-netrc-security-check nil
685 "*If non-nil avoid checking permissions on the .netrc file.")
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.")
692 (defvar ange-ftp-default-password nil
693 "*Password to use when the user is the same as ange-ftp-default-user.")
695 (defvar ange-ftp-default-account nil
696 "*Account password to use when the user is the same as ange-ftp-default-user.")
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.")
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.")
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.")
713 (defvar ange-ftp-gateway-host nil
714 "*Name of host to use as gateway machine when local FTP isn't possible.")
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.")
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.")
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.")
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.")
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.")
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.")
749 (defvar ange-ftp-smart-gateway-port "21"
750 "*Port on gateway machine to use when smart gateway is in operation.")
752 (defvar ange-ftp-send-hash t
753 "*If non-nil, send the HASH command to the FTP client.")
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.")
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.")
766 (defvar ange-ftp-process-verbose t
767 "*If non-NIL then be chatty about interaction with the FTP process.")
769 (defvar ange-ftp-ftp-program-name "ftp"
770 "*Name of FTP program to run.")
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.")
776 (defvar ange-ftp-ftp-program-args '("-i" "-n" "-g" "-v")
777 "*A list of arguments passed to the FTP program when started.")
779 (defvar ange-ftp-nslookup-program nil
780 "*If non-NIL then a string naming nslookup program." )
782 (defvar ange-ftp-make-backup-files ()
783 "*Non-nil means make backup files for \"magic\" remote files.")
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.")
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.")
794 ;;;; ------------------------------------------------------------
795 ;;;; Hash table support.
796 ;;;; ------------------------------------------------------------
798 (require 'backquote)
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))
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))
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)))))
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))))
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)))
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))
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))
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)))
855 ;;;; ------------------------------------------------------------
856 ;;;; Internal variables.
857 ;;;; ------------------------------------------------------------
859 (defconst ange-ftp-version "$Revision: 1.32 $")
861 (defvar ange-ftp-data-buffer-name " *ftp data*"
862 "Buffer name to hold directory listing data received from ftp process.")
864 (defvar ange-ftp-netrc-modtime nil
865 "Last modified time of the netrc file from file-attributes.")
867 (defvar ange-ftp-user-hashtable (ange-ftp-make-hashtable)
868 "Hash table holding associations between HOST, USER pairs.")
870 (defvar ange-ftp-passwd-hashtable (ange-ftp-make-hashtable)
871 "Mapping between a HOST, USER pair and a PASSWORD for them.")
873 (defvar ange-ftp-account-hashtable (ange-ftp-make-hashtable)
874 "Mapping between a HOST, USER pair and a ACCOUNT password for them.")
876 (defvar ange-ftp-files-hashtable (ange-ftp-make-hashtable 97)
877 "Hash table for storing directories and their respective files.")
879 (defvar ange-ftp-ls-cache-lsargs nil
880 "Last set of args used by ange-ftp-ls.")
882 (defvar ange-ftp-ls-cache-file nil
883 "Last file passed to ange-ftp-ls.")
885 (defvar ange-ftp-ls-cache-res nil
886 "Last result returned from ange-ftp-ls.")
888 (defconst ange-ftp-expand-dir-hashtable (ange-ftp-make-hashtable))
890 (defconst ange-ftp-expand-dir-regexp "^5.0 \\([^: ]+\\):")
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)
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)
915 ;; New error symbols.
916 (put 'ftp-error 'error-conditions '(ftp-error file-error error))
917 ;; (put 'ftp-error 'error-message "FTP error")
919 ;;; ------------------------------------------------------------
920 ;;; Match-data support (stolen from Kyle I think)
921 ;;; ------------------------------------------------------------
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)))))
934 (put 'ange-ftp-save-match-data 'lisp-indent-hook 0)
935 (put 'ange-ftp-save-match-data 'edebug-form-hook '(&rest form))
937 ;;; ------------------------------------------------------------
938 ;;; Enhanced message support.
939 ;;; ------------------------------------------------------------
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)))
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 "./")))
966 ;;;; ------------------------------------------------------------
967 ;;;; User / Host mapping support.
968 ;;;; ------------------------------------------------------------
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))
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.
992 (user-login-name))))
993 (ange-ftp-set-user host user)))))
995 ;;;; ------------------------------------------------------------
996 ;;;; Password support.
997 ;;;; ------------------------------------------------------------
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))
1022 (defmacro ange-ftp-generate-passwd-key (host user)
1023 (` (concat (, host) "/" (, user))))
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)))
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))
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))
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)
1063 ;; look up password in the hash table first; user might have overridden the
1064 ;; defaults.
1065 (cond ((ange-ftp-lookup-passwd host user))
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)
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))))
1082 ;; see if same user has logged in to other hosts; if so then prompt
1083 ;; with the password that was used there.
1085 (let* ((other (ange-ftp-get-host-with-passwd user))
1086 (passwd (if other
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))
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))))
1101 ;;;; ------------------------------------------------------------
1102 ;;;; Account support
1103 ;;;; ------------------------------------------------------------
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.
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))
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)))
1128 ;;;; ------------------------------------------------------------
1129 ;;;; ~/.netrc support
1130 ;;;; ------------------------------------------------------------
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)
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))))))
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)))
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."
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))))))
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)))))
1255 ;;;; ------------------------------------------------------------
1256 ;;;; Remote file name syntax support.
1257 ;;;; ------------------------------------------------------------
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))))))
1265 (defvar ange-ftp-ftp-name-arg "")
1266 (defvar ange-ftp-ftp-name-res nil)
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)))))
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)))))))
1297 ;;;; ------------------------------------------------------------
1298 ;;;; Miscellaneous utils.
1299 ;;;; ------------------------------------------------------------
1301 ;; (setq ange-ftp-tmp-keymap (make-sparse-keymap))
1302 ;; (define-key ange-ftp-tmp-keymap "\C-m" 'exit-minibuffer)
1304 (defun ange-ftp-repaint-minibuffer ()
1305 "Clear any existing minibuffer message; let the minibuffer contents show."
1306 (message nil))
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 "*"))
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))))
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))))
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))))))))
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)))
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))))
1371 ;;;; ------------------------------------------------------------
1372 ;;;; FTP process filter support.
1373 ;;;; ------------------------------------------------------------
1375 (defun ange-ftp-process-handle-line (line proc)
1376 "Look at the given LINE from the ftp process PROC. Try to categorize 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)
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
1399 (setq ange-ftp-process-busy nil
1400 ange-ftp-process-result-line line))))
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))))
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))))))))
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)
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))))
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)))
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))
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))
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
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)))
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)
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)))
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)))))
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)))
1538 ;;;; ------------------------------------------------------------
1539 ;;;; Gateway support.
1540 ;;;; ------------------------------------------------------------
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)))))
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)))))
1557 ;;; ------------------------------------------------------------
1558 ;;; Temporary file location and deletion...
1559 ;;; ------------------------------------------------------------
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)
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)))
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))
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)))
1599 ;;;; ------------------------------------------------------------
1600 ;;;; Interactive gateway program support.
1601 ;;;; ------------------------------------------------------------
1603 (defvar ange-ftp-gwp-running t)
1604 (defvar ange-ftp-gwp-status nil)
1606 (defun ange-ftp-gwp-sentinel (proc str)
1607 (setq ange-ftp-gwp-running nil))
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)))))
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))
1663 ;;;; ------------------------------------------------------------
1664 ;;;; Support for sending commands to the ftp process.
1665 ;;;; ------------------------------------------------------------
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
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))))))
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))
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 (internal-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))
1771 (defun internal-ange-ftp-mode ()
1772 (interactive)
1773 (comint-mode)
1774 (setq major-mode 'internal-ange-ftp-mode)
1775 (setq mode-name "Internal 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 "")))
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)))))))
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)))))))
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.")
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))
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)))))))))
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))
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))
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)
1899 ;; Guess at the host type.
1900 (ange-ftp-guess-host-type host user)
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)))
1907 ;; Variables for caching host and host-type
1908 (defvar ange-ftp-host-cache nil)
1909 (defvar ange-ftp-host-type-cache nil)
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?
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)
1943 'unix))))))
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.
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.")
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.")
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.")
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 (ange-ftp-this-user user)
1979 (ange-ftp-this-host host)
1980 (ange-ftp-this-msg msg)
1981 cmd2 cmd3 host-type fix-name-func)
1983 (cond
1985 ;; pwd case (We don't care what host-type.)
1986 ((null cmd1))
1988 ;; cmd == 'dir "remote-name" "local-name" "ls-switches"
1989 ((progn
1990 (setq cmd2 (nth 2 cmd)
1991 host-type (ange-ftp-host-type host user))
1992 ;; This will trigger an FTP login, if one doesn't exist
1993 (eq cmd0 'dir))
1994 (setq cmd1 (funcall
1995 (or (cdr (assq host-type ange-ftp-fix-dir-name-func-alist))
1996 'identity)
1997 cmd1)
1998 cmd3 (nth 3 cmd))
1999 ;; Need to deal with the HP-UX ftp bug. This should also allow
2000 ;; us to resolve symlinks to directories on SysV machines. (Sebastian will
2001 ;; be happy.)
2002 (and (eq host-type 'unix)
2003 (string-match "/$" cmd1)
2004 (not (string-match "R" cmd3))
2005 (setq cmd1 (concat cmd1 ".")))
2006 ;; If the remote ls can take switches, put them in
2007 (or (memq host-type ange-ftp-dumb-host-types)
2008 (setq cmd0 'ls
2009 cmd1 (format "\"%s %s\"" cmd3 cmd1))))
2011 ;; First argument is the remote name
2012 ((progn
2013 (setq fix-name-func (or (cdr (assq host-type
2014 ange-ftp-fix-name-func-alist))
2015 'identity))
2016 (memq cmd0 '(get delete mkdir rmdir cd)))
2017 (setq cmd1 (funcall fix-name-func cmd1)))
2019 ;; Second argument is the remote name
2020 ((memq cmd0 '(append put chmod))
2021 (setq cmd2 (funcall fix-name-func cmd2)))
2023 ;; Both arguments are remote names
2024 ((eq cmd0 'rename)
2025 (setq cmd1 (funcall fix-name-func cmd1)
2026 cmd2 (funcall fix-name-func cmd2))))
2028 ;; Turn the command into one long string
2029 (setq cmd0 (symbol-name cmd0))
2030 (setq cmd (concat cmd0
2031 (and cmd1 (concat " " cmd1))
2032 (and cmd2 (concat " " cmd2))))
2034 ;; Actually send the resulting command.
2035 (let (afsc-result
2036 afsc-line)
2037 (ange-ftp-raw-send-cmd
2038 (ange-ftp-get-process host user)
2041 (list
2042 (function (lambda (result line host user
2043 cmd msg cont nowait)
2044 (or cont
2045 (setq afsc-result result
2046 afsc-line line))
2047 (if result
2048 (ange-ftp-call-cont cont result line)
2049 (ange-ftp-raw-send-cmd
2050 (ange-ftp-get-process host user)
2053 (list
2054 (function (lambda (result line cont)
2055 (or cont
2056 (setq afsc-result result
2057 afsc-line line))
2058 (ange-ftp-call-cont cont result line)))
2059 cont)
2060 nowait))))
2061 host user cmd msg cont nowait)
2062 nowait)
2064 (if nowait
2066 (if cont
2068 (cons afsc-result afsc-line))))))
2070 ;; It might be nice to message users about the host type identified,
2071 ;; but there is so much other messaging going on, it would not be
2072 ;; seen. No point in slowing things down just so users can read
2073 ;; a host type message.
2075 (defconst ange-ftp-cms-name-template
2076 (concat
2077 "^[-A-Z0-9$*][-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?"
2078 "[-A-Z0-9$*]?[-A-Z0-9$*]?[-A-Z0-9$*]?\\.[0-9][0-9][0-9A-Z]$"))
2079 (defconst ange-ftp-vms-name-template
2080 "^[-A-Z0-9_$]+:\\[[-A-Z0-9_$]+\\(\\.[-A-Z0-9_$]+\\)*\\]$")
2081 (defconst ange-ftp-mts-name-template
2082 "^[A-Z0-9._][A-Z0-9._][A-Z0-9._][A-Z0-9._]:$")
2084 (defun ange-ftp-guess-host-type (host user)
2085 "Guess at the the host type of HOST by doing a pwd, and examining
2086 the directory syntax."
2087 (let ((host-type (ange-ftp-host-type host))
2088 (key (concat host "/" user "/~")))
2089 (if (eq host-type 'unix)
2090 ;; Note that ange-ftp-host-type returns unix as the default value.
2091 (ange-ftp-save-match-data
2092 (let* ((result (ange-ftp-get-pwd host user))
2093 (dir (car result))
2094 fix-name-func)
2095 (cond ((null dir)
2096 (message "Warning! Unable to get home directory")
2097 (sit-for 1)
2098 (if (string-match
2099 "^450 No current working directory defined$"
2100 (cdr result))
2102 ;; We'll assume that if pwd bombs with this
2103 ;; error message, then it's CMS.
2104 (progn
2105 (ange-ftp-add-cms-host host)
2106 (setq ange-ftp-host-cache host
2107 ange-ftp-host-type-cache 'cms))))
2109 ;; try for VMS
2110 ((string-match ange-ftp-vms-name-template dir)
2111 (ange-ftp-add-vms-host host)
2112 ;; The add-host functions clear the host type cache.
2113 ;; Therefore, need to set the cache afterwards.
2114 (setq ange-ftp-host-cache host
2115 ange-ftp-host-type-cache 'vms))
2117 ;; try for MTS
2118 ((string-match ange-ftp-mts-name-template dir)
2119 (ange-ftp-add-mts-host host)
2120 (setq ange-ftp-host-cache host
2121 ange-ftp-host-type-cache 'mts))
2123 ;; try for CMS
2124 ((string-match ange-ftp-cms-name-template dir)
2125 (ange-ftp-add-cms-host host)
2126 (setq ange-ftp-host-cache host
2127 ange-ftp-host-type-cache 'cms))
2129 ;; assume UN*X
2131 (setq ange-ftp-host-cache host
2132 ange-ftp-host-type-cache 'unix)))
2134 ;; Now that we have done a pwd, might as well put it in
2135 ;; the expand-dir hashtable.
2136 (let ((ange-ftp-this-user user)
2137 (ange-ftp-this-host host))
2138 (setq fix-name-func (cdr (assq ange-ftp-host-type-cache
2139 ange-ftp-fix-name-func-alist)))
2140 (if fix-name-func
2141 (setq dir (funcall fix-name-func dir 'reverse))))
2142 (ange-ftp-put-hash-entry key dir
2143 ange-ftp-expand-dir-hashtable))))
2145 ;; In the special case of CMS make sure that know the
2146 ;; expansion of the home minidisk now, because we will
2147 ;; be doing a lot of cd's.
2148 (if (and (eq host-type 'cms)
2149 (not (ange-ftp-hash-entry-exists-p
2150 key ange-ftp-expand-dir-hashtable)))
2151 (let ((dir (car (ange-ftp-get-pwd host user))))
2152 (if dir
2153 (ange-ftp-put-hash-entry key (concat "/" dir)
2154 ange-ftp-expand-dir-hashtable)
2155 (message "Warning! Unable to get home directory")
2156 (sit-for 1))))))
2159 ;;;; ------------------------------------------------------------
2160 ;;;; Remote file and directory listing support.
2161 ;;;; ------------------------------------------------------------
2163 (defun ange-ftp-dumb-unix-host (host)
2164 "Returns whether HOST's FTP server doesn't like \'ls\' or \'dir\' commands
2165 to take switch arguments."
2166 (and ange-ftp-dumb-unix-host-regexp
2167 (ange-ftp-save-match-data
2168 (string-match ange-ftp-dumb-unix-host-regexp host))))
2170 (defun ange-ftp-add-dumb-unix-host (host)
2171 "Interactively adds a given HOST to ange-ftp-dumb-unix-host-regexp."
2172 (interactive
2173 (list (read-string "Host: "
2174 (let ((name (or (buffer-file-name) default-directory)))
2175 (and name (car (ange-ftp-ftp-name name)))))))
2176 (if (not (ange-ftp-dumb-unix-host host))
2177 (setq ange-ftp-dumb-unix-host-regexp
2178 (concat "^" (regexp-quote host) "$"
2179 (and ange-ftp-dumb-unix-host-regexp "\\|")
2180 ange-ftp-dumb-unix-host-regexp)
2181 ange-ftp-host-cache nil)))
2183 (defvar ange-ftp-parse-list-func-alist nil
2184 "Association list of \( TYPE \. FUNC \) pairs. The FUNC is a routine
2185 which can parse the output from a DIR listing for a host of type TYPE.")
2187 ;; With no-error nil, this function returns:
2188 ;; an error if file is not an ange-ftp-name
2189 ;; (This should never happen.)
2190 ;; an error if either the listing is unreadable or there is an ftp error.
2191 ;; the listing (a string), if everything works.
2193 ;; With no-error t, it returns:
2194 ;; an error if not an ange-ftp-name
2195 ;; error if listing is unreable (most likely caused by a slow connection)
2196 ;; nil if ftp error (this is because although asking to list a nonexistent
2197 ;; directory on a remote unix machine usually (except
2198 ;; maybe for dumb hosts) returns an ls error, but no
2199 ;; ftp error, if the same is done on a VMS machine,
2200 ;; an ftp error is returned. Need to trap the error
2201 ;; so we can go on and try to list the parent.)
2202 ;; the listing, if everything works.
2204 ;; If WILDCARD is non-nil, then this implements the guts of insert-directory
2205 ;; in the wildcard case. Then we make a relative directory listing
2206 ;; of FILE within the directory specified by `default-directory'.
2208 (defun ange-ftp-ls (file lsargs parse &optional no-error wildcard)
2209 "Return the output of an `DIR' or `ls' command done over ftp.
2210 FILE is the full name of the remote file, LSARGS is any args to pass to the
2211 `ls' command, and PARSE specifies that the output should be parsed and stored
2212 away in the internal cache."
2213 ;; If parse is t, we assume that file is a directory. i.e. we only parse
2214 ;; full directory listings.
2215 (let* ((ange-ftp-this-file (ange-ftp-expand-file-name file))
2216 (parsed (ange-ftp-ftp-name ange-ftp-this-file)))
2217 (if parsed
2218 (let* ((host (nth 0 parsed))
2219 (user (nth 1 parsed))
2220 (name (ange-ftp-quote-string (nth 2 parsed)))
2221 (key (directory-file-name ange-ftp-this-file))
2222 (host-type (ange-ftp-host-type host user))
2223 (dumb (memq host-type ange-ftp-dumb-host-types))
2224 result
2225 temp
2226 lscmd parse-func)
2227 (if (string-equal name "")
2228 (setq name
2229 (ange-ftp-real-file-name-as-directory
2230 (ange-ftp-expand-dir host user "~"))))
2231 (if (and ange-ftp-ls-cache-file
2232 (string-equal key ange-ftp-ls-cache-file)
2233 ;; Don't care about lsargs for dumb hosts.
2234 (or dumb (string-equal lsargs ange-ftp-ls-cache-lsargs)))
2235 ange-ftp-ls-cache-res
2236 (setq temp (ange-ftp-make-tmp-name host))
2237 (if wildcard
2238 (progn
2239 (ange-ftp-cd host user (file-name-directory name))
2240 (setq lscmd (list 'dir file temp lsargs)))
2241 (setq lscmd (list 'dir name temp lsargs)))
2242 (unwind-protect
2243 (if (car (setq result (ange-ftp-send-cmd
2244 host
2245 user
2246 lscmd
2247 (format "Listing %s"
2248 (ange-ftp-abbreviate-filename
2249 ange-ftp-this-file)))))
2250 (save-excursion
2251 (set-buffer (get-buffer-create
2252 ange-ftp-data-buffer-name))
2253 (erase-buffer)
2254 (if (ange-ftp-real-file-readable-p temp)
2255 (ange-ftp-real-insert-file-contents temp)
2256 (sleep-for ange-ftp-retry-time)
2257 ;wait for file to possibly appear
2258 (if (ange-ftp-real-file-readable-p temp)
2259 ;; Try again.
2260 (ange-ftp-real-insert-file-contents temp)
2261 (ange-ftp-error host user
2262 (format
2263 "list data file %s not readable"
2264 temp))))
2265 (if parse
2266 (ange-ftp-set-files
2267 ange-ftp-this-file
2268 (if (setq
2269 parse-func
2270 (cdr (assq host-type
2271 ange-ftp-parse-list-func-alist)))
2272 (funcall parse-func)
2273 (ange-ftp-parse-dired-listing lsargs))))
2274 (setq ange-ftp-ls-cache-file key
2275 ange-ftp-ls-cache-lsargs lsargs
2276 ; For dumb hosts-types this is
2277 ; meaningless but harmless.
2278 ange-ftp-ls-cache-res (buffer-string))
2279 ;; (kill-buffer (current-buffer))
2280 ange-ftp-ls-cache-res)
2281 (if no-error
2283 (ange-ftp-error host user
2284 (concat "DIR failed: " (cdr result)))))
2285 (ange-ftp-del-tmp-name temp))))
2286 (error "Should never happen. Please report. Bug ref. no.: 1"))))
2288 ;;;; ------------------------------------------------------------
2289 ;;;; Directory information caching support.
2290 ;;;; ------------------------------------------------------------
2292 (defconst ange-ftp-date-regexp
2293 (concat
2294 " \\(Jan\\|Feb\\|Mar\\|Apr\\|May\\|Jun\\|Jul\\|Aug\\|Sep\\|Oct"
2295 "\\|Nov\\|Dec\\) +[0-3]?[0-9] "))
2297 (defvar ange-ftp-add-file-entry-alist nil
2298 "Association list of pairs \( TYPE \. FUNC \), where FUNC
2299 is a function to be used to add a file entry for the OS TYPE. The
2300 main reason for this alist is to deal with file versions in VMS.")
2302 (defvar ange-ftp-delete-file-entry-alist nil
2303 "Association list of pairs \( TYPE \. FUNC \), where FUNC
2304 is a function to be used to delete a file entry for the OS TYPE.
2305 The main reason for this alist is to deal with file versions in
2306 VMS.")
2308 (defun ange-ftp-add-file-entry (name &optional dir-p)
2309 "Add a file entry for file NAME, if its directory info exists."
2310 (funcall (or (cdr (assq (ange-ftp-host-type
2311 (car (ange-ftp-ftp-name name)))
2312 ange-ftp-add-file-entry-alist))
2313 'ange-ftp-internal-add-file-entry)
2314 name dir-p)
2315 (setq ange-ftp-ls-cache-file nil))
2317 (defun ange-ftp-delete-file-entry (name &optional dir-p)
2318 "Delete the file entry for file NAME, if its directory info exists."
2319 (funcall (or (cdr (assq (ange-ftp-host-type
2320 (car (ange-ftp-ftp-name name)))
2321 ange-ftp-delete-file-entry-alist))
2322 'ange-ftp-internal-delete-file-entry)
2323 name dir-p)
2324 (setq ange-ftp-ls-cache-file nil))
2326 (defmacro ange-ftp-parse-filename ()
2327 ;;Extract the filename from the current line of a dired-like listing.
2328 (` (let ((eol (progn (end-of-line) (point))))
2329 (beginning-of-line)
2330 (if (re-search-forward ange-ftp-date-regexp eol t)
2331 (progn
2332 (skip-chars-forward " ")
2333 (skip-chars-forward "^ " eol)
2334 (skip-chars-forward " " eol)
2335 ;; We bomb on filenames starting with a space.
2336 (buffer-substring (point) eol))))))
2338 ;; This deals with the F switch. Should also do something about
2339 ;; unquoting names obtained with the SysV b switch and the GNU Q
2340 ;; switch. See Sebastian's dired-get-filename.
2342 (defmacro ange-ftp-ls-parser ()
2343 ;; Note that switches is dynamically bound.
2344 ;; Meant to be called by ange-ftp-parse-dired-listing
2345 (` (let ((tbl (ange-ftp-make-hashtable))
2346 (used-F (and (stringp switches)
2347 (string-match "F" switches)))
2348 file-type symlink directory file)
2349 (while (setq file (ange-ftp-parse-filename))
2350 (beginning-of-line)
2351 (skip-chars-forward "\t 0-9")
2352 (setq file-type (following-char)
2353 directory (eq file-type ?d))
2354 (if (eq file-type ?l)
2355 (if (string-match " -> " file)
2356 (setq symlink (substring file (match-end 0))
2357 file (substring file 0 (match-beginning 0)))
2358 ;; Shouldn't happen
2359 (setq symlink ""))
2360 (setq symlink nil))
2361 ;; Only do a costly regexp search if the F switch was used.
2362 (if (and used-F
2363 (not (string-equal file ""))
2364 (looking-at
2365 ".[-r][-w]\\([^ ]\\)[-r][-w]\\([^ ]\\)[-r][-w]\\([^ ]\\)"))
2366 (let ((socket (eq file-type ?s))
2367 (executable
2368 (and (not symlink) ; x bits don't mean a thing for symlinks
2369 (string-match "[xst]"
2370 (concat
2371 (buffer-substring
2372 (match-beginning 1)
2373 (match-end 1))
2374 (buffer-substring
2375 (match-beginning 2)
2376 (match-end 2))
2377 (buffer-substring
2378 (match-beginning 3)
2379 (match-end 3)))))))
2380 ;; Some ls's with the F switch mark symlinks with an @ (ULTRIX)
2381 ;; and others don't. (sigh...) Beware, that some Unix's don't
2382 ;; seem to believe in the F-switch
2383 (if (or (and symlink (string-match "@$" file))
2384 (and directory (string-match "/$" file))
2385 (and executable (string-match "*$" file))
2386 (and socket (string-match "=$" file)))
2387 (setq file (substring file 0 -1)))))
2388 (ange-ftp-put-hash-entry file (or symlink directory) tbl)
2389 (forward-line 1))
2390 (ange-ftp-put-hash-entry "." t tbl)
2391 (ange-ftp-put-hash-entry ".." t tbl)
2392 tbl)))
2394 ;;; The dl stuff for descriptive listings
2396 (defvar ange-ftp-dl-dir-regexp nil
2397 "Regexp matching directories which are listed in dl format. This regexp
2398 shouldn't be anchored with a trailing $ so that it will match subdirectories
2399 as well.")
2401 (defun ange-ftp-add-dl-dir (dir)
2402 "Interactively adds a DIR to ange-ftp-dl-dir-regexp."
2403 (interactive
2404 (list (read-string "Directory: "
2405 (let ((name (or (buffer-file-name) default-directory)))
2406 (and name (ange-ftp-ftp-name name)
2407 (file-name-directory name))))))
2408 (if (not (and ange-ftp-dl-dir-regexp
2409 (string-match ange-ftp-dl-dir-regexp dir)))
2410 (setq ange-ftp-dl-dir-regexp
2411 (concat "^" (regexp-quote dir)
2412 (and ange-ftp-dl-dir-regexp "\\|")
2413 ange-ftp-dl-dir-regexp))))
2415 (defmacro ange-ftp-dl-parser ()
2416 ;; Parse the current buffer, which is assumed to be a descriptive
2417 ;; listing, and return a hashtable.
2418 (` (let ((tbl (ange-ftp-make-hashtable)))
2419 (while (not (eobp))
2420 (ange-ftp-put-hash-entry
2421 (buffer-substring (point)
2422 (progn
2423 (skip-chars-forward "^ /\n")
2424 (point)))
2425 (eq (following-char) ?/)
2426 tbl)
2427 (forward-line 1))
2428 (ange-ftp-put-hash-entry "." t tbl)
2429 (ange-ftp-put-hash-entry ".." t tbl)
2430 tbl)))
2432 (defun ange-ftp-parse-dired-listing (&optional switches)
2433 "Parse the current buffer which is assumed to be in a dired-like listing
2434 format, and return a hashtable as the result. If the listing is not really
2435 a listing, then return nil."
2436 (ange-ftp-save-match-data
2437 (cond
2438 ((looking-at "^total [0-9]+$")
2439 (forward-line 1)
2440 (ange-ftp-ls-parser))
2441 ((looking-at "[^\n]+\\( not found\\|: Not a directory\\)\n\\'")
2442 ;; It's an ls error message.
2443 nil)
2444 ((eobp) ; i.e. (zerop (buffer-size))
2445 ;; This could be one of:
2446 ;; (1) An Ultrix ls error message
2447 ;; (2) A listing with the A switch of an empty directory
2448 ;; on a machine which doesn't give a total line.
2449 ;; (3) The twilight zone.
2450 ;; We'll assume (1) for now.
2451 nil)
2452 ((re-search-forward ange-ftp-date-regexp nil t)
2453 (beginning-of-line)
2454 (ange-ftp-ls-parser))
2455 ((re-search-forward "^[^ \n\t]+ +\\([0-9]+\\|-\\|=\\) " nil t)
2456 ;; It's a dl listing (I hope).
2457 ;; file is bound by the call to ange-ftp-ls
2458 (ange-ftp-add-dl-dir ange-ftp-this-file)
2459 (beginning-of-line)
2460 (ange-ftp-dl-parser))
2461 (t nil))))
2463 (defun ange-ftp-set-files (directory files)
2464 "For a given DIRECTORY, set or change the associated FILES hashtable."
2465 (and files (ange-ftp-put-hash-entry (file-name-as-directory directory)
2466 files ange-ftp-files-hashtable)))
2468 (defun ange-ftp-get-files (directory &optional no-error)
2469 "Given a given DIRECTORY, return a hashtable of file entries.
2470 This will give an error or return nil, depending on the value of
2471 NO-ERROR, if a listing for DIRECTORY cannot be obtained."
2472 (setq directory (file-name-as-directory directory)) ;normalize
2473 (or (ange-ftp-get-hash-entry directory ange-ftp-files-hashtable)
2474 (ange-ftp-save-match-data
2475 (and (ange-ftp-ls directory
2476 ;; This is an efficiency hack. We try to
2477 ;; anticipate what sort of listing dired
2478 ;; might want, and cache just such a listing.
2479 (if (and (boundp 'dired-actual-switches)
2480 (stringp dired-actual-switches)
2481 ;; We allow the A switch, which lists
2482 ;; all files except "." and "..".
2483 ;; This is OK because we manually
2484 ;; insert these entries
2485 ;; in the hash table.
2486 (string-match
2487 "[aA]" dired-actual-switches)
2488 (string-match
2489 "l" dired-actual-switches)
2490 (not (string-match
2491 "R" dired-actual-switches)))
2492 dired-actual-switches
2493 (if (and (boundp 'dired-listing-switches)
2494 (stringp dired-listing-switches)
2495 (string-match
2496 "[aA]" dired-listing-switches)
2497 (string-match
2498 "l" dired-listing-switches)
2499 (not (string-match
2500 "R" dired-listing-switches)))
2501 dired-listing-switches
2502 "-al"))
2503 t no-error)
2504 (ange-ftp-get-hash-entry
2505 directory ange-ftp-files-hashtable)))))
2507 (defmacro ange-ftp-get-file-part (name)
2508 "Given NAME, return the file part that can be used for looking up the
2509 file's entry in a hashtable."
2510 (` (let ((file (file-name-nondirectory (, name))))
2511 (if (string-equal file "")
2513 file))))
2515 (defmacro ange-ftp-allow-child-lookup (dir file)
2516 "Return whether ange-ftp-file-entry-p and ange-ftp-get-file-entry are
2517 allowed to determine if NAME is a sub-directory by listing it directly,
2518 rather than listing its parent directory. This is used for efficiency so
2519 that a wasted listing is not done:
2520 1. When looking for a .dired file in dired-x.el.
2521 2. The syntax of FILE and DIR make it impossible that FILE could be a valid
2522 subdirectory. This is of course an OS dependent judgement."
2523 (` (not
2524 (let* ((efile (, file)) ; expand once.
2525 (edir (, dir))
2526 (parsed (ange-ftp-ftp-name edir))
2527 (host-type (ange-ftp-host-type
2528 (car parsed))))
2530 ;;; This variable seems not to exist in Emacs 19 -- rms.
2531 ;;; ;; Deal with dired
2532 ;;; (and (boundp 'dired-local-variables-file)
2533 ;;; (stringp dired-local-variables-file)
2534 ;;; (string-equal dired-local-variables-file efile))
2535 ;; No dots in dir names in vms.
2536 (and (eq host-type 'vms)
2537 (string-match "\\." efile))
2538 ;; No subdirs in mts of cms.
2539 (and (memq host-type '(mts cms))
2540 (not (string-equal "/" (nth 2 parsed)))))))))
2542 (defun ange-ftp-file-entry-p (name)
2543 "Given NAME, return whether there is a file entry for it."
2544 (let* ((name (directory-file-name name))
2545 (dir (file-name-directory name))
2546 (ent (ange-ftp-get-hash-entry dir ange-ftp-files-hashtable))
2547 (file (ange-ftp-get-file-part name)))
2548 (if ent
2549 (ange-ftp-hash-entry-exists-p file ent)
2550 (or (and (ange-ftp-allow-child-lookup dir file)
2551 (setq ent (ange-ftp-get-files name t))
2552 ;; Try a child lookup. i.e. try to list file as a
2553 ;; subdirectory of dir. This is a good idea because
2554 ;; we may not have read permission for file's parent. Also,
2555 ;; people tend to work down directory trees anyway. We use
2556 ;; no-error ;; because if file does not exist as a subdir.,
2557 ;; then dumb hosts will give an ftp error. Smart unix hosts
2558 ;; will simply send back the ls
2559 ;; error message.
2560 (ange-ftp-get-hash-entry "." ent))
2561 ;; Child lookup failed. Try the parent. If this bombs,
2562 ;; we are at wits end -- signal an error.
2563 ;; Problem: If this signals an error, the error message
2564 ;; may not have a lot to do with what went wrong.
2565 (ange-ftp-hash-entry-exists-p file
2566 (ange-ftp-get-files dir))))))
2568 (defun ange-ftp-get-file-entry (name)
2569 "Given NAME, return the given file entry.
2570 The entry will be either t for a directory, nil for a normal file,
2571 or a string for a symlink. If the file isn't in the hashtable,
2572 this also returns nil."
2573 (let* ((name (directory-file-name name))
2574 (dir (file-name-directory name))
2575 (ent (ange-ftp-get-hash-entry dir ange-ftp-files-hashtable))
2576 (file (ange-ftp-get-file-part name)))
2577 (if ent
2578 (ange-ftp-get-hash-entry file ent)
2579 (or (and (ange-ftp-allow-child-lookup dir file)
2580 (setq ent (ange-ftp-get-files name t))
2581 (ange-ftp-get-hash-entry "." ent))
2582 ;; i.e. it's a directory by child lookup
2583 (ange-ftp-get-hash-entry file
2584 (ange-ftp-get-files dir))))))
2586 (defun ange-ftp-internal-delete-file-entry (name &optional dir-p)
2587 (if dir-p
2588 (progn
2589 (setq name (file-name-as-directory name))
2590 (ange-ftp-del-hash-entry name ange-ftp-files-hashtable)
2591 (setq name (directory-file-name name))))
2592 ;; Note that file-name-as-directory followed by directory-file-name
2593 ;; serves to canonicalize directory file names to their unix form.
2594 ;; i.e. in VMS, FOO.DIR -> FOO/ -> FOO
2595 (let ((files (ange-ftp-get-hash-entry (file-name-directory name)
2596 ange-ftp-files-hashtable)))
2597 (if files
2598 (ange-ftp-del-hash-entry (ange-ftp-get-file-part name)
2599 files))))
2601 (defun ange-ftp-internal-add-file-entry (name &optional dir-p)
2602 (and dir-p
2603 (setq name (directory-file-name name)))
2604 (let ((files (ange-ftp-get-hash-entry (file-name-directory name)
2605 ange-ftp-files-hashtable)))
2606 (if files
2607 (ange-ftp-put-hash-entry (ange-ftp-get-file-part name)
2608 dir-p
2609 files))))
2611 (defun ange-ftp-wipe-file-entries (host user)
2612 "Replace the file entry information hashtable with one that doesn't have any
2613 entries for the given HOST, USER pair."
2614 (let ((new-tbl (ange-ftp-make-hashtable (length ange-ftp-files-hashtable))))
2615 (ange-ftp-map-hashtable
2616 (function
2617 (lambda (key val)
2618 (let ((parsed (ange-ftp-ftp-name key)))
2619 (if parsed
2620 (let ((h (nth 0 parsed))
2621 (u (nth 1 parsed)))
2622 (or (and (equal host h) (equal user u))
2623 (ange-ftp-put-hash-entry key val new-tbl)))))))
2624 ange-ftp-files-hashtable)
2625 (setq ange-ftp-files-hashtable new-tbl)))
2627 ;;;; ------------------------------------------------------------
2628 ;;;; File transfer mode support.
2629 ;;;; ------------------------------------------------------------
2631 (defun ange-ftp-set-binary-mode (host user)
2632 "Tell the ftp process for the given HOST & USER to switch to binary mode."
2633 (let ((result (ange-ftp-send-cmd host user '(type "binary"))))
2634 (if (not (car result))
2635 (ange-ftp-error host user (concat "BINARY failed: " (cdr result)))
2636 (save-excursion
2637 (set-buffer (process-buffer (ange-ftp-get-process host user)))
2638 (setq ange-ftp-hash-mark-unit (ash ange-ftp-binary-hash-mark-size -4))))))
2640 (defun ange-ftp-set-ascii-mode (host user)
2641 "Tell the ftp process for the given HOST & USER to switch to ascii mode."
2642 (let ((result (ange-ftp-send-cmd host user '(type "ascii"))))
2643 (if (not (car result))
2644 (ange-ftp-error host user (concat "ASCII failed: " (cdr result)))
2645 (save-excursion
2646 (set-buffer (process-buffer (ange-ftp-get-process host user)))
2647 (setq ange-ftp-hash-mark-unit (ash ange-ftp-ascii-hash-mark-size -4))))))
2649 (defun ange-ftp-cd (host user dir)
2650 (let ((result (ange-ftp-send-cmd host user (list 'cd dir) "Doing CD")))
2651 (or (car result)
2652 (ange-ftp-error host user (concat "CD failed: " (cdr result))))))
2654 (defun ange-ftp-get-pwd (host user)
2655 "Attempts to get the current working directory for the given HOST/USER pair.
2656 Returns \( DIR . LINE \) where DIR is either the directory or NIL if not found,
2657 and LINE is the relevant success or fail line from the FTP-client."
2658 (let* ((result (ange-ftp-send-cmd host user '(pwd) "Getting PWD"))
2659 (line (cdr result))
2660 dir)
2661 (if (car result)
2662 (ange-ftp-save-match-data
2663 (and (or (string-match "\"\\([^\"]*\\)\"" line)
2664 (string-match " \\([^ ]+\\) " line)) ; stone-age VMS servers!
2665 (setq dir (substring line
2666 (match-beginning 1)
2667 (match-end 1))))))
2668 (cons dir line)))
2670 ;;; ------------------------------------------------------------
2671 ;;; expand-file-name and friends...which currently don't work
2672 ;;; ------------------------------------------------------------
2674 (defun ange-ftp-expand-dir (host user dir)
2675 "Return the result of doing a PWD in the current FTP session to machine HOST
2676 logged in as user USER and cd'd to directory DIR."
2677 (let* ((host-type (ange-ftp-host-type host user))
2678 ;; It is more efficient to call ange-ftp-host-type
2679 ;; before binding res, because ange-ftp-host-type sometimes
2680 ;; adds to the info in the expand-dir-hashtable.
2681 (fix-name-func
2682 (cdr (assq host-type ange-ftp-fix-name-func-alist)))
2683 (key (concat host "/" user "/" dir))
2684 (res (ange-ftp-get-hash-entry key ange-ftp-expand-dir-hashtable)))
2685 (or res
2686 (progn
2688 (string-equal user "anonymous")
2689 (string-equal user "ftp")
2690 (not (eq host-type 'unix))
2691 (let* ((ange-ftp-good-msgs (concat ange-ftp-expand-dir-regexp
2692 "\\|"
2693 ange-ftp-good-msgs))
2694 (result (ange-ftp-send-cmd host user
2695 (list 'get dir "/dev/null")
2696 (format "expanding %s" dir)))
2697 (line (cdr result)))
2698 (setq res
2699 (if (string-match ange-ftp-expand-dir-regexp line)
2700 (substring line
2701 (match-beginning 1)
2702 (match-end 1))))))
2703 (or res
2704 (if (string-equal dir "~")
2705 (setq res (car (ange-ftp-get-pwd host user)))
2706 (let ((home (ange-ftp-expand-dir host user "~")))
2707 (unwind-protect
2708 (and (ange-ftp-cd host user dir)
2709 (setq res (car (ange-ftp-get-pwd host user))))
2710 (ange-ftp-cd host user home)))))
2711 (if res
2712 (let ((ange-ftp-this-user user)
2713 (ange-ftp-this-host host))
2714 (if fix-name-func
2715 (setq res (funcall fix-name-func res 'reverse)))
2716 (ange-ftp-put-hash-entry
2717 key res ange-ftp-expand-dir-hashtable)))
2718 res))))
2720 (defun ange-ftp-canonize-filename (n)
2721 "Take a string and short-circuit //, /. and /.."
2722 (if (string-match ".+//" n) ;don't upset Apollo users
2723 (setq n (substring n (1- (match-end 0)))))
2724 (let ((parsed (ange-ftp-ftp-name n)))
2725 (if parsed
2726 (let ((host (car parsed))
2727 (user (nth 1 parsed))
2728 (name (nth 2 parsed)))
2730 ;; See if remote name is absolute. If so then just expand it and
2731 ;; replace the name component of the overall name.
2732 (cond ((string-match "^/" name)
2733 name)
2735 ;; Name starts with ~ or ~user. Resolve that part of the name
2736 ;; making it absolute then re-expand it.
2737 ((string-match "^~[^/]*" name)
2738 (let* ((tilda (substring name
2739 (match-beginning 0)
2740 (match-end 0)))
2741 (rest (substring name (match-end 0)))
2742 (dir (ange-ftp-expand-dir host user tilda)))
2743 (if dir
2744 (setq name (concat dir rest))
2745 (error "User \"%s\" is not known"
2746 (substring tilda 1)))))
2748 ;; relative name. Tack on homedir and re-expand.
2750 (let ((dir (ange-ftp-expand-dir host user "~")))
2751 (if dir
2752 (setq name (concat
2753 (ange-ftp-real-file-name-as-directory dir)
2754 name))
2755 (error "Unable to obtain CWD")))))
2757 (setq name (ange-ftp-real-expand-file-name name))
2759 ;; see if hit real expand-file-name bug... this will probably annoy
2760 ;; some Apollo people. I'll wait until they shout, however.
2761 (if (string-match "^//" name)
2762 (setq name (substring name 1)))
2764 ;; Now substitute the expanded name back into the overall filename.
2765 (ange-ftp-replace-name-component n name))
2767 ;; non-ange-ftp name. Just expand normally.
2768 (if (eq (string-to-char n) ?/)
2769 (ange-ftp-real-expand-file-name n)
2770 (ange-ftp-real-expand-file-name
2771 (ange-ftp-real-file-name-nondirectory n)
2772 (ange-ftp-real-file-name-directory n))))))
2774 (defun ange-ftp-expand-file-name (name &optional default)
2775 "Documented as original."
2776 (ange-ftp-save-match-data
2777 (if (eq (string-to-char name) ?/)
2778 (while (cond ((string-match ".+//" name) ;don't upset Apollo users
2779 (setq name (substring name (1- (match-end 0)))))
2780 ((string-match "/~" name)
2781 (setq name (substring name (1- (match-end 0))))))))
2782 (cond ((eq (string-to-char name) ?~)
2783 (ange-ftp-real-expand-file-name name))
2784 ((eq (string-to-char name) ?/)
2785 (ange-ftp-canonize-filename name))
2786 ((zerop (length name))
2787 (ange-ftp-canonize-filename (or default default-directory)))
2788 ((ange-ftp-canonize-filename
2789 (concat (file-name-as-directory (or default default-directory))
2790 name))))))
2792 ;;; These are problems--they are currently not enabled.
2794 (defvar ange-ftp-file-name-as-directory-alist nil
2795 "Association list of \( TYPE \. FUNC \) pairs, where
2796 FUNC converts a filename to a directory name for the operating
2797 system TYPE.")
2799 (defun ange-ftp-file-name-as-directory (name)
2800 "Documented as original."
2801 (let ((parsed (ange-ftp-ftp-name name)))
2802 (if parsed
2803 (if (string-equal (nth 2 parsed) "")
2804 name
2805 (funcall (or (cdr (assq
2806 (ange-ftp-host-type (car parsed))
2807 ange-ftp-file-name-as-directory-alist))
2808 'ange-ftp-real-file-name-as-directory)
2809 name))
2810 (ange-ftp-real-file-name-as-directory name))))
2812 (defun ange-ftp-file-name-directory (name)
2813 "Documented as original."
2814 (let ((parsed (ange-ftp-ftp-name name)))
2815 (if parsed
2816 (let ((filename (nth 2 parsed)))
2817 (if (ange-ftp-save-match-data
2818 (string-match "^~[^/]*$" filename))
2819 name
2820 (ange-ftp-replace-name-component
2821 name
2822 (ange-ftp-real-file-name-directory filename))))
2823 (ange-ftp-real-file-name-directory name))))
2825 (defun ange-ftp-file-name-nondirectory (name)
2826 "Documented as original."
2827 (let ((parsed (ange-ftp-ftp-name name)))
2828 (if parsed
2829 (let ((filename (nth 2 parsed)))
2830 (if (ange-ftp-save-match-data
2831 (string-match "^~[^/]*$" filename))
2833 (ange-ftp-real-file-name-nondirectory name)))
2834 (ange-ftp-real-file-name-nondirectory name))))
2836 (defun ange-ftp-directory-file-name (dir)
2837 "Documented as original."
2838 (let ((parsed (ange-ftp-ftp-name dir)))
2839 (if parsed
2840 (ange-ftp-replace-name-component
2842 (ange-ftp-real-directory-file-name (nth 2 parsed)))
2843 (ange-ftp-real-directory-file-name dir))))
2846 ;;; Hooks that handle Emacs primitives.
2848 ;; Returns non-nil if should transfer FILE in binary mode.
2849 (defun ange-ftp-binary-file (file)
2850 (ange-ftp-save-match-data
2851 (string-match ange-ftp-binary-file-name-regexp file)))
2853 (defun ange-ftp-write-region (start end filename &optional append visit)
2854 (setq filename (expand-file-name filename))
2855 (let ((parsed (ange-ftp-ftp-name filename)))
2856 (if parsed
2857 (let* ((host (nth 0 parsed))
2858 (user (nth 1 parsed))
2859 (name (ange-ftp-quote-string (nth 2 parsed)))
2860 (temp (ange-ftp-make-tmp-name host))
2861 (binary (ange-ftp-binary-file filename))
2862 (cmd (if append 'append 'put))
2863 (abbr (ange-ftp-abbreviate-filename filename)))
2864 (unwind-protect
2865 (progn
2866 (let ((executing-macro t)
2867 (filename (buffer-file-name))
2868 (mod-p (buffer-modified-p)))
2869 (unwind-protect
2870 (ange-ftp-real-write-region start end temp nil visit)
2871 ;; cleanup forms
2872 (setq buffer-file-name filename)
2873 (set-buffer-modified-p mod-p)))
2874 (if binary
2875 (ange-ftp-set-binary-mode host user))
2877 ;; tell the process filter what size the transfer will be.
2878 (let ((attr (file-attributes temp)))
2879 (if attr
2880 (ange-ftp-set-xfer-size host user (nth 7 attr))))
2882 ;; put or append the file.
2883 (let ((result (ange-ftp-send-cmd host user
2884 (list cmd temp name)
2885 (format "Writing %s" abbr))))
2886 (or (car result)
2887 (signal 'ftp-error
2888 (list
2889 "Opening output file"
2890 (format "FTP Error: \"%s\"" (cdr result))
2891 filename)))))
2892 (ange-ftp-del-tmp-name temp)
2893 (if binary
2894 (ange-ftp-set-ascii-mode host user)))
2895 (if (eq visit t)
2896 (progn
2897 (ange-ftp-set-buffer-mode)
2898 (setq buffer-file-name filename)
2899 (set-buffer-modified-p nil)))
2900 (ange-ftp-message "Wrote %s" abbr)
2901 (ange-ftp-add-file-entry filename))
2902 (ange-ftp-real-write-region start end filename append visit))))
2904 (defun ange-ftp-insert-file-contents (filename &optional visit beg end)
2905 (barf-if-buffer-read-only)
2906 (setq filename (expand-file-name filename))
2907 (let ((parsed (ange-ftp-ftp-name filename)))
2908 (if parsed
2909 (progn
2910 (if visit
2911 (setq buffer-file-name filename))
2912 (if (or (file-exists-p filename)
2913 (progn
2914 (setq ange-ftp-ls-cache-file nil)
2915 (ange-ftp-del-hash-entry (file-name-directory filename)
2916 ange-ftp-files-hashtable)
2917 (file-exists-p filename)))
2918 (let* ((host (nth 0 parsed))
2919 (user (nth 1 parsed))
2920 (name (ange-ftp-quote-string (nth 2 parsed)))
2921 (temp (ange-ftp-make-tmp-name host))
2922 (binary (ange-ftp-binary-file filename))
2923 (abbr (ange-ftp-abbreviate-filename filename))
2924 size)
2925 (unwind-protect
2926 (progn
2927 (if binary
2928 (ange-ftp-set-binary-mode host user))
2929 (let ((result (ange-ftp-send-cmd host user
2930 (list 'get name temp)
2931 (format "Retrieving %s" abbr))))
2932 (or (car result)
2933 (signal 'ftp-error
2934 (list
2935 "Opening input file"
2936 (format "FTP Error: \"%s\"" (cdr result))
2937 filename))))
2938 (if (or (ange-ftp-real-file-readable-p temp)
2939 (sleep-for ange-ftp-retry-time)
2940 ;; Wait for file to hopefully appear.
2941 (ange-ftp-real-file-readable-p temp))
2942 (setq
2943 size
2944 (nth 1 (ange-ftp-real-insert-file-contents temp
2945 visit
2946 beg end)))
2947 (signal 'ftp-error
2948 (list
2949 "Opening input file:"
2950 (format
2951 "FTP Error: %s not arrived or readable"
2952 filename)))))
2953 (if binary
2954 (ange-ftp-set-ascii-mode host user))
2955 (ange-ftp-del-tmp-name temp))
2956 (if visit
2957 (setq buffer-file-name filename))
2958 (list filename size))
2959 (signal 'file-error
2960 (list
2961 "Opening input file"
2962 filename))))
2963 (ange-ftp-real-insert-file-contents filename visit beg end))))
2965 (defun ange-ftp-expand-symlink (file dir)
2966 (if (file-name-absolute-p file)
2967 (ange-ftp-replace-name-component dir file)
2968 (expand-file-name file dir)))
2970 (defun ange-ftp-file-symlink-p (file)
2971 ;; call ange-ftp-expand-file-name rather than the normal
2972 ;; expand-file-name to stop loops when using a package that
2973 ;; redefines both file-symlink-p and expand-file-name.
2974 (setq file (ange-ftp-expand-file-name file))
2975 (if (ange-ftp-ftp-name file)
2976 (let ((file-ent
2977 (ange-ftp-get-hash-entry
2978 (ange-ftp-get-file-part file)
2979 (ange-ftp-get-files (file-name-directory file)))))
2980 (if (stringp file-ent)
2981 (if (file-name-absolute-p file-ent)
2982 (ange-ftp-replace-name-component
2983 (file-name-directory file) file-ent)
2984 file-ent)))
2985 (ange-ftp-real-file-symlink-p file)))
2987 (defun ange-ftp-file-exists-p (name)
2988 (setq name (expand-file-name name))
2989 (if (ange-ftp-ftp-name name)
2990 (if (ange-ftp-file-entry-p name)
2991 (let ((file-ent (ange-ftp-get-file-entry name)))
2992 (if (stringp file-ent)
2993 (file-exists-p
2994 (ange-ftp-expand-symlink file-ent
2995 (file-name-directory
2996 (directory-file-name name))))
2997 t)))
2998 (ange-ftp-real-file-exists-p name)))
3000 (defun ange-ftp-file-directory-p (name)
3001 (setq name (expand-file-name name))
3002 (if (ange-ftp-ftp-name name)
3003 ;; We do a file-name-as-directory on name here because some
3004 ;; machines (VMS) use a .DIR to indicate the filename associated
3005 ;; with a directory. This needs to be canonicalized.
3006 (let ((file-ent (ange-ftp-get-file-entry
3007 (ange-ftp-file-name-as-directory name))))
3008 (if (stringp file-ent)
3009 (file-directory-p
3010 (ange-ftp-expand-symlink file-ent
3011 (file-name-directory
3012 (directory-file-name name))))
3013 file-ent))
3014 (ange-ftp-real-file-directory-p name)))
3016 (defun ange-ftp-directory-files (directory &optional full match
3017 &rest v19-args)
3018 (setq directory (expand-file-name directory))
3019 (if (ange-ftp-ftp-name directory)
3020 (progn
3021 (ange-ftp-barf-if-not-directory directory)
3022 (let ((tail (ange-ftp-hash-table-keys
3023 (ange-ftp-get-files directory)))
3024 files f)
3025 (setq directory (file-name-as-directory directory))
3026 (ange-ftp-save-match-data
3027 (while tail
3028 (setq f (car tail)
3029 tail (cdr tail))
3030 (if (or (not match) (string-match match f))
3031 (setq files
3032 (cons (if full (concat directory f) f) files)))))
3033 (nreverse files)))
3034 (apply 'ange-ftp-real-directory-files directory full match v19-args)))
3036 (defun ange-ftp-file-attributes (file)
3037 (setq file (expand-file-name file))
3038 (let ((parsed (ange-ftp-ftp-name file)))
3039 (if parsed
3040 (let ((part (ange-ftp-get-file-part file))
3041 (files (ange-ftp-get-files (file-name-directory file))))
3042 (if (ange-ftp-hash-entry-exists-p part files)
3043 (let ((host (nth 0 parsed))
3044 (user (nth 1 parsed))
3045 (name (nth 2 parsed))
3046 (dirp (ange-ftp-get-hash-entry part files)))
3047 (list (if (and (stringp dirp) (file-name-absolute-p dirp))
3048 (ange-ftp-expand-symlink dirp
3049 (file-name-directory file))
3050 dirp) ;0 file type
3051 -1 ;1 link count
3052 -1 ;2 uid
3053 -1 ;3 gid
3054 '(0 0) ;4 atime
3055 '(0 0) ;5 mtime
3056 '(0 0) ;6 ctime
3057 -1 ;7 size
3058 (concat (if (stringp dirp) "l" (if dirp "d" "-"))
3059 "?????????") ;8 mode
3060 nil ;9 gid weird
3061 ;; Hack to give remote files a unique "inode number".
3062 ;; It's actually the sum of the characters in its name.
3063 (apply '+ (nconc (mapcar 'identity host)
3064 (mapcar 'identity user)
3065 (mapcar 'identity
3066 (directory-file-name name))))
3067 -1 ;11 device number [v19 only]
3068 ))))
3069 (ange-ftp-real-file-attributes file))))
3071 (defun ange-ftp-file-writable-p (file)
3072 (setq file (expand-file-name file))
3073 (if (ange-ftp-ftp-name file)
3074 (or (file-exists-p file) ;guess here for speed
3075 (file-directory-p (file-name-directory file)))
3076 (ange-ftp-real-file-writable-p file)))
3078 (defun ange-ftp-file-readable-p (file)
3079 (setq file (expand-file-name file))
3080 (if (ange-ftp-ftp-name file)
3081 (file-exists-p file)
3082 (ange-ftp-real-file-readable-p file)))
3084 (defun ange-ftp-file-executable-p (file)
3085 (setq file (expand-file-name file))
3086 (if (ange-ftp-ftp-name file)
3087 (file-exists-p file)
3088 (ange-ftp-real-file-executable-p file)))
3090 (defun ange-ftp-delete-file (file)
3091 (interactive "fDelete file: ")
3092 (setq file (expand-file-name file))
3093 (let ((parsed (ange-ftp-ftp-name file)))
3094 (if parsed
3095 (let* ((host (nth 0 parsed))
3096 (user (nth 1 parsed))
3097 (name (ange-ftp-quote-string (nth 2 parsed)))
3098 (abbr (ange-ftp-abbreviate-filename file))
3099 (result (ange-ftp-send-cmd host user
3100 (list 'delete name)
3101 (format "Deleting %s" abbr))))
3102 (or (car result)
3103 (signal 'ftp-error
3104 (list
3105 "Removing old name"
3106 (format "FTP Error: \"%s\"" (cdr result))
3107 file)))
3108 (ange-ftp-delete-file-entry file))
3109 (ange-ftp-real-delete-file file))))
3111 (defun ange-ftp-verify-visited-file-modtime (buf)
3112 (let ((name (buffer-file-name buf)))
3113 (if (and (stringp name) (ange-ftp-ftp-name name))
3115 (ange-ftp-real-verify-visited-file-modtime buf))))
3117 ;;;; ------------------------------------------------------------
3118 ;;;; File copying support... totally re-written 6/24/92.
3119 ;;;; ------------------------------------------------------------
3121 (defun ange-ftp-barf-or-query-if-file-exists (absname querystring interactive)
3122 (if (file-exists-p absname)
3123 (if (not interactive)
3124 (signal 'file-already-exists (list absname))
3125 (if (not (yes-or-no-p (format "File %s already exists; %s anyway? "
3126 absname querystring)))
3127 (signal 'file-already-exists (list absname))))))
3129 ;; async local copy commented out for now since I don't seem to get
3130 ;; the process sentinel called for some processes.
3132 ;; (defun ange-ftp-copy-file-locally (filename newname ok-if-already-exists
3133 ;; keep-date cont)
3134 ;; "Kludge to copy a local file and call a continuation when the copy
3135 ;; finishes."
3136 ;; ;; check to see if we can overwrite
3137 ;; (if (or (not ok-if-already-exists)
3138 ;; (numberp ok-if-already-exists))
3139 ;; (ange-ftp-barf-or-query-if-file-exists newname "copy to it"
3140 ;; (numberp ok-if-already-exists)))
3141 ;; (let ((proc (start-process " *copy*"
3142 ;; (generate-new-buffer "*copy*")
3143 ;; "cp"
3144 ;; filename
3145 ;; newname))
3146 ;; res)
3147 ;; (set-process-sentinel proc (function ange-ftp-copy-file-locally-sentinel))
3148 ;; (process-kill-without-query proc)
3149 ;; (save-excursion
3150 ;; (set-buffer (process-buffer proc))
3151 ;; (make-variable-buffer-local 'copy-cont)
3152 ;; (setq copy-cont cont))))
3154 ;; (defun ange-ftp-copy-file-locally-sentinel (proc status)
3155 ;; (save-excursion
3156 ;; (set-buffer (process-buffer proc))
3157 ;; (let ((cont copy-cont)
3158 ;; (result (buffer-string)))
3159 ;; (unwind-protect
3160 ;; (if (and (string-equal status "finished\n")
3161 ;; (zerop (length result)))
3162 ;; (ange-ftp-call-cont cont t nil)
3163 ;; (ange-ftp-call-cont cont
3164 ;; nil
3165 ;; (if (zerop (length result))
3166 ;; (substring status 0 -1)
3167 ;; (substring result 0 -1))))
3168 ;; (kill-buffer (current-buffer))))))
3170 ;; this is the extended version of ange-ftp-copy-file-internal that works
3171 ;; asynchronously if asked nicely.
3172 (defun ange-ftp-copy-file-internal (filename newname ok-if-already-exists
3173 keep-date &optional msg cont nowait)
3174 (setq filename (expand-file-name filename)
3175 newname (expand-file-name newname))
3177 ;; canonicalize newname if a directory.
3178 (if (file-directory-p newname)
3179 (setq newname (expand-file-name (file-name-nondirectory filename) newname)))
3181 (let ((f-parsed (ange-ftp-ftp-name filename))
3182 (t-parsed (ange-ftp-ftp-name newname)))
3184 ;; local file to local file copy?
3185 (if (and (not f-parsed) (not t-parsed))
3186 (progn
3187 (ange-ftp-real-copy-file filename newname ok-if-already-exists
3188 keep-date)
3189 (if cont
3190 (ange-ftp-call-cont cont t "Copied locally")))
3191 ;; one or both files are remote.
3192 (let* ((f-host (and f-parsed (nth 0 f-parsed)))
3193 (f-user (and f-parsed (nth 1 f-parsed)))
3194 (f-name (and f-parsed (ange-ftp-quote-string (nth 2 f-parsed))))
3195 (f-abbr (ange-ftp-abbreviate-filename filename))
3196 (t-host (and t-parsed (nth 0 t-parsed)))
3197 (t-user (and t-parsed (nth 1 t-parsed)))
3198 (t-name (and t-parsed (ange-ftp-quote-string (nth 2 t-parsed))))
3199 (t-abbr (ange-ftp-abbreviate-filename newname filename))
3200 (binary (or (ange-ftp-binary-file filename)
3201 (ange-ftp-binary-file newname)))
3202 temp1
3203 temp2)
3205 ;; check to see if we can overwrite
3206 (if (or (not ok-if-already-exists)
3207 (numberp ok-if-already-exists))
3208 (ange-ftp-barf-or-query-if-file-exists newname "copy to it"
3209 (numberp ok-if-already-exists)))
3211 ;; do the copying.
3212 (if f-parsed
3214 ;; filename was remote.
3215 (progn
3216 (if (or (ange-ftp-use-gateway-p f-host)
3217 t-parsed)
3218 ;; have to use intermediate file if we are getting via
3219 ;; gateway machine or we are doing a remote to remote copy.
3220 (setq temp1 (ange-ftp-make-tmp-name f-host)))
3222 (if binary
3223 (ange-ftp-set-binary-mode f-host f-user))
3225 (ange-ftp-send-cmd
3226 f-host
3227 f-user
3228 (list 'get f-name (or temp1 newname))
3229 (or msg
3230 (if (and temp1 t-parsed)
3231 (format "Getting %s" f-abbr)
3232 (format "Copying %s to %s" f-abbr t-abbr)))
3233 (list (function ange-ftp-cf1)
3234 filename newname binary msg
3235 f-parsed f-host f-user f-name f-abbr
3236 t-parsed t-host t-user t-name t-abbr
3237 temp1 temp2 cont nowait)
3238 nowait))
3240 ;; filename wasn't remote. newname must be remote. call the
3241 ;; function which does the remainder of the copying work.
3242 (ange-ftp-cf1 t nil
3243 filename newname binary msg
3244 f-parsed f-host f-user f-name f-abbr
3245 t-parsed t-host t-user t-name t-abbr
3246 nil nil cont nowait))))))
3248 ;; next part of copying routine.
3249 (defun ange-ftp-cf1 (result line
3250 filename newname binary msg
3251 f-parsed f-host f-user f-name f-abbr
3252 t-parsed t-host t-user t-name t-abbr
3253 temp1 temp2 cont nowait)
3254 (if line
3255 ;; filename must have been remote, and we must have just done a GET.
3256 (unwind-protect
3257 (or result
3258 ;; GET failed for some reason. Clean up and get out.
3259 (progn
3260 (and temp1 (ange-ftp-del-tmp-name temp1))
3261 (or cont
3262 (signal 'ftp-error (list "Opening input file"
3263 (format "FTP Error: \"%s\"" line)
3264 filename)))))
3265 ;; cleanup
3266 (if binary
3267 (ange-ftp-set-ascii-mode f-host f-user))))
3269 (if result
3270 ;; We now have to copy either temp1 or filename to newname.
3271 (if t-parsed
3273 ;; newname was remote.
3274 (progn
3275 (if (ange-ftp-use-gateway-p t-host)
3276 (setq temp2 (ange-ftp-make-tmp-name t-host)))
3278 ;; make sure data is moved into the right place for the
3279 ;; outgoing transfer. gateway temporary files complicate
3280 ;; things nicely.
3281 (if temp1
3282 (if temp2
3283 (if (string-equal temp1 temp2)
3284 (setq temp1 nil)
3285 (ange-ftp-real-copy-file temp1 temp2 t))
3286 (setq temp2 temp1 temp1 nil))
3287 (if temp2
3288 (ange-ftp-real-copy-file filename temp2 t)))
3290 (if binary
3291 (ange-ftp-set-binary-mode t-host t-user))
3293 ;; tell the process filter what size the file is.
3294 (let ((attr (file-attributes (or temp2 filename))))
3295 (if attr
3296 (ange-ftp-set-xfer-size t-host t-user (nth 7 attr))))
3298 (ange-ftp-send-cmd
3299 t-host
3300 t-user
3301 (list 'put (or temp2 filename) t-name)
3302 (or msg
3303 (if (and temp2 f-parsed)
3304 (format "Putting %s" newname)
3305 (format "Copying %s to %s" f-abbr t-abbr)))
3306 (list (function ange-ftp-cf2)
3307 newname t-host t-user binary temp1 temp2 cont)
3308 nowait))
3310 ;; newname wasn't remote.
3311 (ange-ftp-cf2 t nil newname t-host t-user binary temp1 temp2 cont))
3313 ;; first copy failed, tell caller
3314 (ange-ftp-call-cont cont result line)))
3316 ;; last part of copying routine.
3317 (defun ange-ftp-cf2 (result line newname t-host t-user binary temp1 temp2 cont)
3318 (unwind-protect
3319 (if line
3320 ;; result from doing a local to remote copy.
3321 (unwind-protect
3322 (progn
3323 (or result
3324 (or cont
3325 (signal 'ftp-error
3326 (list "Opening output file"
3327 (format "FTP Error: \"%s\"" line)
3328 newname))))
3330 (ange-ftp-add-file-entry newname))
3332 ;; cleanup.
3333 (if binary
3334 (ange-ftp-set-ascii-mode t-host t-user)))
3336 ;; newname was local.
3337 (if temp1
3338 (ange-ftp-real-copy-file temp1 newname t)))
3340 ;; clean up
3341 (and temp1 (ange-ftp-del-tmp-name temp1))
3342 (and temp2 (ange-ftp-del-tmp-name temp2))
3343 (ange-ftp-call-cont cont result line)))
3345 (defun ange-ftp-copy-file (filename newname &optional ok-if-already-exists
3346 keep-date)
3347 (interactive "fCopy file: \nFCopy %s to file: \np")
3348 (ange-ftp-copy-file-internal filename
3349 newname
3350 ok-if-already-exists
3351 keep-date
3354 (interactive-p)))
3356 ;;;; ------------------------------------------------------------
3357 ;;;; File renaming support.
3358 ;;;; ------------------------------------------------------------
3360 (defun ange-ftp-rename-remote-to-remote (filename newname f-parsed t-parsed
3361 binary)
3362 "Rename remote file FILE to remote file NEWNAME."
3363 (let ((f-host (nth 0 f-parsed))
3364 (f-user (nth 1 f-parsed))
3365 (t-host (nth 0 t-parsed))
3366 (t-user (nth 1 t-parsed)))
3367 (if (and (string-equal f-host t-host)
3368 (string-equal f-user t-user))
3369 (let* ((f-name (ange-ftp-quote-string (nth 2 f-parsed)))
3370 (t-name (ange-ftp-quote-string (nth 2 t-parsed)))
3371 (cmd (list 'rename f-name t-name))
3372 (fabbr (ange-ftp-abbreviate-filename filename))
3373 (nabbr (ange-ftp-abbreviate-filename newname filename))
3374 (result (ange-ftp-send-cmd f-host f-user cmd
3375 (format "Renaming %s to %s"
3376 fabbr
3377 nabbr))))
3378 (or (car result)
3379 (signal 'ftp-error
3380 (list
3381 "Renaming"
3382 (format "FTP Error: \"%s\"" (cdr result))
3383 filename
3384 newname)))
3385 (ange-ftp-add-file-entry newname)
3386 (ange-ftp-delete-file-entry filename))
3387 (ange-ftp-copy-file-internal filename newname t nil)
3388 (delete-file filename))))
3390 (defun ange-ftp-rename-local-to-remote (filename newname)
3391 "Rename local FILENAME to remote file NEWNAME."
3392 (let* ((fabbr (ange-ftp-abbreviate-filename filename))
3393 (nabbr (ange-ftp-abbreviate-filename newname filename))
3394 (msg (format "Renaming %s to %s" fabbr nabbr)))
3395 (ange-ftp-copy-file-internal filename newname t nil msg)
3396 (let (ange-ftp-process-verbose)
3397 (delete-file filename))))
3399 (defun ange-ftp-rename-remote-to-local (filename newname)
3400 "Rename remote file FILENAME to local file NEWNAME."
3401 (let* ((fabbr (ange-ftp-abbreviate-filename filename))
3402 (nabbr (ange-ftp-abbreviate-filename newname filename))
3403 (msg (format "Renaming %s to %s" fabbr nabbr)))
3404 (ange-ftp-copy-file-internal filename newname t nil msg)
3405 (let (ange-ftp-process-verbose)
3406 (delete-file filename))))
3408 (defun ange-ftp-rename-file (filename newname &optional ok-if-already-exists)
3409 (interactive "fRename file: \nFRename %s to file: \np")
3410 (setq filename (expand-file-name filename))
3411 (setq newname (expand-file-name newname))
3412 (let* ((f-parsed (ange-ftp-ftp-name filename))
3413 (t-parsed (ange-ftp-ftp-name newname))
3414 (binary (if (or f-parsed t-parsed) (ange-ftp-binary-file filename))))
3415 (if (and (or f-parsed t-parsed)
3416 (or (not ok-if-already-exists)
3417 (numberp ok-if-already-exists)))
3418 (ange-ftp-barf-or-query-if-file-exists
3419 newname
3420 "rename to it"
3421 (numberp ok-if-already-exists)))
3422 (if f-parsed
3423 (if t-parsed
3424 (ange-ftp-rename-remote-to-remote filename newname f-parsed
3425 t-parsed binary)
3426 (ange-ftp-rename-remote-to-local filename newname))
3427 (if t-parsed
3428 (ange-ftp-rename-local-to-remote filename newname)
3429 (ange-ftp-real-rename-file filename newname ok-if-already-exists)))))
3431 ;;;; ------------------------------------------------------------
3432 ;;;; File name completion support.
3433 ;;;; ------------------------------------------------------------
3435 ;; If the file entry SYM is a symlink, returns whether its file exists.
3436 ;; Note that `ange-ftp-this-dir' is used as a free variable.
3437 (defun ange-ftp-file-entry-active-p (sym)
3438 (let ((val (get sym 'val)))
3439 (or (not (stringp val))
3440 (file-exists-p (ange-ftp-expand-symlink val ange-ftp-this-dir)))))
3442 ;; If the file entry is not a directory (nor a symlink pointing to a directory)
3443 ;; returns whether the file (or file pointed to by the symlink) is ignored
3444 ;; by completion-ignored-extensions.
3445 ;; Note that `ange-ftp-this-dir' and `ange-ftp-completion-ignored-pattern'
3446 ;; are used as free variables.
3447 (defun ange-ftp-file-entry-not-ignored-p (sym)
3448 (let ((val (get sym 'val))
3449 (symname (symbol-name sym)))
3450 (if (stringp val)
3451 (let ((file (ange-ftp-expand-symlink val ange-ftp-this-dir)))
3452 (or (file-directory-p file)
3453 (and (file-exists-p file)
3454 (not (string-match ange-ftp-completion-ignored-pattern
3455 symname)))))
3456 (or val ; is a directory name
3457 (not (string-match ange-ftp-completion-ignored-pattern symname))))))
3459 (defun ange-ftp-file-name-all-completions (file dir)
3460 (let ((ange-ftp-this-dir (expand-file-name dir)))
3461 (if (ange-ftp-ftp-name ange-ftp-this-dir)
3462 (progn
3463 (ange-ftp-barf-if-not-directory ange-ftp-this-dir)
3464 (setq ange-ftp-this-dir
3465 (ange-ftp-real-file-name-as-directory ange-ftp-this-dir))
3466 (let* ((tbl (ange-ftp-get-files ange-ftp-this-dir))
3467 (completions
3468 (all-completions file tbl
3469 (function ange-ftp-file-entry-active-p))))
3471 ;; see whether each matching file is a directory or not...
3472 (mapcar
3473 (function
3474 (lambda (file)
3475 (let ((ent (ange-ftp-get-hash-entry file tbl)))
3476 (if (and ent
3477 (or (not (stringp ent))
3478 (file-directory-p
3479 (ange-ftp-expand-symlink ent
3480 ange-ftp-this-dir))))
3481 (concat file "/")
3482 file))))
3483 completions)))
3485 (if (string-equal "/" ange-ftp-this-dir)
3486 (nconc (all-completions file (ange-ftp-generate-root-prefixes))
3487 (ange-ftp-real-file-name-all-completions file
3488 ange-ftp-this-dir))
3489 (ange-ftp-real-file-name-all-completions file ange-ftp-this-dir)))))
3491 (defun ange-ftp-file-name-completion (file dir)
3492 (let ((ange-ftp-this-dir (expand-file-name dir)))
3493 (if (ange-ftp-ftp-name ange-ftp-this-dir)
3494 (progn
3495 (ange-ftp-barf-if-not-directory ange-ftp-this-dir)
3496 (if (equal file "")
3498 (setq ange-ftp-this-dir
3499 (ange-ftp-real-file-name-as-directory ange-ftp-this-dir)) ;real?
3500 (let* ((tbl (ange-ftp-get-files ange-ftp-this-dir))
3501 (ange-ftp-completion-ignored-pattern
3502 (mapconcat (function
3503 (lambda (s) (if (stringp s)
3504 (concat (regexp-quote s) "$")
3505 "/"))) ; / never in filename
3506 completion-ignored-extensions
3507 "\\|")))
3508 (ange-ftp-save-match-data
3509 (or (ange-ftp-file-name-completion-1
3510 file tbl ange-ftp-this-dir
3511 (function ange-ftp-file-entry-not-ignored-p))
3512 (ange-ftp-file-name-completion-1
3513 file tbl ange-ftp-this-dir
3514 (function ange-ftp-file-entry-active-p)))))))
3516 (if (string-equal "/" ange-ftp-this-dir)
3517 (try-completion
3518 file
3519 (nconc (ange-ftp-generate-root-prefixes)
3520 (mapcar 'list
3521 (ange-ftp-real-file-name-all-completions file "/"))))
3522 (ange-ftp-real-file-name-completion file ange-ftp-this-dir)))))
3525 (defun ange-ftp-file-name-completion-1 (file tbl dir predicate)
3526 (let ((bestmatch (try-completion file tbl predicate)))
3527 (if bestmatch
3528 (if (eq bestmatch t)
3529 (if (file-directory-p (expand-file-name file dir))
3530 (concat file "/")
3532 (if (and (eq (try-completion bestmatch tbl predicate) t)
3533 (file-directory-p
3534 (expand-file-name bestmatch dir)))
3535 (concat bestmatch "/")
3536 bestmatch)))))
3538 ;; Put these lines uncommmented in your .emacs if you want C-r to refresh
3539 ;; ange-ftp's cache whilst doing filename completion.
3541 ;;(define-key minibuffer-local-completion-map "\C-r" 'ange-ftp-re-read-dir)
3542 ;;(define-key minibuffer-local-must-match-map "\C-r" 'ange-ftp-re-read-dir)
3544 ;; Force a re-read of the directory DIR. If DIR is omitted then it defaults
3545 ;; to the directory part of the contents of the current buffer.
3546 (defun ange-ftp-re-read-dir (&optional dir)
3547 (interactive)
3548 (if dir
3549 (setq dir (expand-file-name dir))
3550 (setq dir (file-name-directory (expand-file-name (buffer-string)))))
3551 (if (ange-ftp-ftp-name dir)
3552 (progn
3553 (setq ange-ftp-ls-cache-file nil)
3554 (ange-ftp-del-hash-entry dir ange-ftp-files-hashtable)
3555 (ange-ftp-get-files dir t))))
3557 (defun ange-ftp-make-directory (dir &optional parents)
3558 (interactive (list (expand-file-name (read-file-name "Make directory: "))))
3559 (if parents
3560 (let ((parent (file-name-directory (directory-file-name dir))))
3561 (or (file-exists-p parent)
3562 (ange-ftp-make-directory parent parents))))
3563 (if (file-exists-p dir)
3564 (error "Cannot make directory %s: file already exists" dir)
3565 (let ((parsed (ange-ftp-ftp-name dir)))
3566 (if parsed
3567 (let* ((host (nth 0 parsed))
3568 (user (nth 1 parsed))
3569 ;; Some ftp's on unix machines (at least on Suns)
3570 ;; insist that mkdir take a filename, and not a
3571 ;; directory-name name as an arg. Argh!! This is a bug.
3572 ;; Non-unix machines will probably always insist
3573 ;; that mkdir takes a directory-name as an arg
3574 ;; (as the ftp man page says it should).
3575 (name (ange-ftp-quote-string
3576 (if (eq (ange-ftp-host-type host) 'unix)
3577 (ange-ftp-real-directory-file-name (nth 2 parsed))
3578 (ange-ftp-real-file-name-as-directory
3579 (nth 2 parsed)))))
3580 (abbr (ange-ftp-abbreviate-filename dir))
3581 (result (ange-ftp-send-cmd host user
3582 (list 'mkdir name)
3583 (format "Making directory %s"
3584 abbr))))
3585 (or (car result)
3586 (ange-ftp-error host user
3587 (format "Could not make directory %s: %s"
3589 (cdr result))))
3590 (ange-ftp-add-file-entry dir t))
3591 (ange-ftp-real-make-directory dir)))))
3593 (defun ange-ftp-delete-directory (dir)
3594 (if (file-directory-p dir)
3595 (let ((parsed (ange-ftp-ftp-name dir)))
3596 (if parsed
3597 (let* ((host (nth 0 parsed))
3598 (user (nth 1 parsed))
3599 ;; Some ftp's on unix machines (at least on Suns)
3600 ;; insist that rmdir take a filename, and not a
3601 ;; directory-name name as an arg. Argh!! This is a bug.
3602 ;; Non-unix machines will probably always insist
3603 ;; that rmdir takes a directory-name as an arg
3604 ;; (as the ftp man page says it should).
3605 (name (ange-ftp-quote-string
3606 (if (eq (ange-ftp-host-type host) 'unix)
3607 (ange-ftp-real-directory-file-name
3608 (nth 2 parsed))
3609 (ange-ftp-real-file-name-as-directory
3610 (nth 2 parsed)))))
3611 (abbr (ange-ftp-abbreviate-filename dir))
3612 (result (ange-ftp-send-cmd host user
3613 (list 'rmdir name)
3614 (format "Removing directory %s"
3615 abbr))))
3616 (or (car result)
3617 (ange-ftp-error host user
3618 (format "Could not remove directory %s: %s"
3620 (cdr result))))
3621 (ange-ftp-delete-file-entry dir t))
3622 (ange-ftp-real-delete-directory dir)))
3623 (error "Not a directory: %s" dir)))
3625 ;; Make a local copy of FILE and return its name.
3627 (defun ange-ftp-file-local-copy (file)
3628 (let* ((fn1 (expand-file-name file))
3629 (pa1 (ange-ftp-ftp-name fn1)))
3630 (if pa1
3631 (let* ((tmp1 (ange-ftp-make-tmp-name (car pa1)))
3632 (bin1 (ange-ftp-binary-file fn1)))
3633 (ange-ftp-copy-file-internal fn1 tmp1 t nil
3634 (format "Getting %s" fn1))
3635 tmp1))))
3637 (defun ange-ftp-load (file)
3638 (if (ange-ftp-ftp-name file)
3639 (let ((copy (ange-ftp-file-local-copy file)))
3640 (unwind-protect
3641 (load copy)
3642 (delete-file copy)))
3643 (ange-ftp-real-load file)))
3645 ;; Calculate default-unhandled-directory for a given ange-ftp buffer.
3646 (defun ange-ftp-unhandled-file-name-directory (filename)
3647 (file-name-directory ange-ftp-tmp-name-template))
3650 ;; Need the following functions for making filenames of compressed
3651 ;; files, because some OS's (unlike UNIX) do not allow a filename to
3652 ;; have two extensions.
3654 (defvar ange-ftp-make-compressed-filename-alist nil
3655 "Alist of host-type-specific functions to process file names for compression.
3656 Each element has the form (TYPE . FUNC).
3657 FUNC should take one argument, a file name, and return a list
3658 of the form (COMPRESSING NEWNAME).
3659 COMPRESSING should be t if the specified file should be compressed,
3660 and nil if it should be uncompressed (that is, if it is a compressed file).
3661 NEWNAME should be the name to give the new compressed or uncompressed file.")
3663 (defun ange-ftp-dired-compress-file (name)
3664 (let ((parsed (ange-ftp-ftp-name name))
3665 conversion-func)
3666 (if (and parsed
3667 (setq conversion-func
3668 (cdr (assq (ange-ftp-host-type (car parsed))
3669 ange-ftp-make-compressed-filename-alist))))
3670 (let* ((decision
3671 (ange-ftp-save-match-data (funcall conversion-func name)))
3672 (compressing (car decision))
3673 (newfile (nth 1 decision)))
3674 (if compressing
3675 (ange-ftp-compress name newfile)
3676 (ange-ftp-uncompress name newfile)))
3677 (let (file-name-handler-alist)
3678 (dired-compress-file name)))))
3680 ;; Copy FILE to this machine, compress it, and copy out to NFILE.
3681 (defun ange-ftp-compress (file nfile)
3682 (let* ((parsed (ange-ftp-ftp-name file))
3683 (tmp1 (ange-ftp-make-tmp-name (car parsed)))
3684 (tmp2 (ange-ftp-make-tmp-name (car parsed)))
3685 (abbr (ange-ftp-abbreviate-filename file))
3686 (nabbr (ange-ftp-abbreviate-filename nfile))
3687 (msg1 (format "Getting %s" abbr))
3688 (msg2 (format "Putting %s" nabbr)))
3689 (unwind-protect
3690 (progn
3691 (ange-ftp-copy-file-internal file tmp1 t nil msg1)
3692 (and ange-ftp-process-verbose
3693 (ange-ftp-message "Compressing %s..." abbr))
3694 (call-process-region (point)
3695 (point)
3696 shell-file-name
3700 "-c"
3701 (format "compress -f -c < %s > %s" tmp1 tmp2))
3702 (and ange-ftp-process-verbose
3703 (ange-ftp-message "Compressing %s...done" abbr))
3704 (if (zerop (buffer-size))
3705 (progn
3706 (let (ange-ftp-process-verbose)
3707 (delete-file file))
3708 (ange-ftp-copy-file-internal tmp2 nfile t nil msg2))))
3709 (ange-ftp-del-tmp-name tmp1)
3710 (ange-ftp-del-tmp-name tmp2))))
3712 ;; Copy FILE to this machine, uncompress it, and copy out to NFILE.
3713 (defun ange-ftp-uncompress (file nfile)
3714 (let* ((parsed (ange-ftp-ftp-name file))
3715 (tmp1 (ange-ftp-make-tmp-name (car parsed)))
3716 (tmp2 (ange-ftp-make-tmp-name (car parsed)))
3717 (abbr (ange-ftp-abbreviate-filename file))
3718 (nabbr (ange-ftp-abbreviate-filename nfile))
3719 (msg1 (format "Getting %s" abbr))
3720 (msg2 (format "Putting %s" nabbr))
3721 ;; ;; Cheap hack because of problems with binary file transfers from
3722 ;; ;; VMS hosts.
3723 ;; (gbinary (not (eq 'vms (ange-ftp-host-type (car parsed)))))
3725 (unwind-protect
3726 (progn
3727 (ange-ftp-copy-file-internal file tmp1 t nil msg1)
3728 (and ange-ftp-process-verbose
3729 (ange-ftp-message "Uncompressing %s..." abbr))
3730 (call-process-region (point)
3731 (point)
3732 shell-file-name
3736 "-c"
3737 (format "uncompress -c < %s > %s" tmp1 tmp2))
3738 (and ange-ftp-process-verbose
3739 (ange-ftp-message "Uncompressing %s...done" abbr))
3740 (if (zerop (buffer-size))
3741 (progn
3742 (let (ange-ftp-process-verbose)
3743 (delete-file file))
3744 (ange-ftp-copy-file-internal tmp2 nfile t nil msg2))))
3745 (ange-ftp-del-tmp-name tmp1)
3746 (ange-ftp-del-tmp-name tmp2))))
3748 ;;; Define the handler for special file names
3749 ;;; that causes ange-ftp to be invoked.
3751 ;;;###autoload
3752 (defun ange-ftp-hook-function (operation &rest args)
3753 (let ((fn (get operation 'ange-ftp)))
3754 (if fn (apply fn args)
3755 (let (file-name-handler-alist)
3756 (apply operation args)))))
3759 ;;; This regexp takes care of real ange-ftp file names (with a slash
3760 ;;; and colon).
3761 ;;;###autoload
3762 (or (assoc "^/[^/:]*[^/:]:" file-name-handler-alist)
3763 (setq file-name-handler-alist
3764 (cons '("^/[^/:]*[^/:]:" . ange-ftp-hook-function)
3765 file-name-handler-alist)))
3767 ;;; This regexp recognizes and absolute filenames with only one component,
3768 ;;; for the sake of hostname completion.
3769 ;;;###autoload
3770 (or (assoc "^/[^/:]*\\'" file-name-handler-alist)
3771 (setq file-name-handler-alist
3772 (cons '("^/[^/:]*\\'" . ange-ftp-completion-hook-function)
3773 file-name-handler-alist)))
3775 ;;; The above two forms are sufficient to cause this file to be loaded
3776 ;;; if the user ever uses a file name with a colon in it.
3778 ;;; This sets the mode
3779 (or (memq 'ange-ftp-set-buffer-mode find-file-hooks)
3780 (setq find-file-hooks
3781 (cons 'ange-ftp-set-buffer-mode find-file-hooks)))
3783 ;;; Now say where to find the handlers for particular operations.
3785 (put 'file-name-directory 'ange-ftp 'ange-ftp-file-name-directory)
3786 (put 'file-name-nondirectory 'ange-ftp 'ange-ftp-file-name-nondirectory)
3787 (put 'file-name-as-directory 'ange-ftp 'ange-ftp-file-name-as-directory)
3788 (put 'directory-file-name 'ange-ftp 'ange-ftp-directory-file-name)
3789 (put 'expand-file-name 'ange-ftp 'ange-ftp-expand-file-name)
3790 (put 'make-directory 'ange-ftp 'ange-ftp-make-directory)
3791 (put 'delete-directory 'ange-ftp 'ange-ftp-delete-directory)
3792 (put 'insert-file-contents 'ange-ftp 'ange-ftp-insert-file-contents)
3793 (put 'directory-files 'ange-ftp 'ange-ftp-directory-files)
3794 (put 'file-directory-p 'ange-ftp 'ange-ftp-file-directory-p)
3795 (put 'file-writable-p 'ange-ftp 'ange-ftp-file-writable-p)
3796 (put 'file-readable-p 'ange-ftp 'ange-ftp-file-readable-p)
3797 (put 'file-executable-p 'ange-ftp 'ange-ftp-file-executable-p)
3798 (put 'file-symlink-p 'ange-ftp 'ange-ftp-file-symlink-p)
3799 (put 'delete-file 'ange-ftp 'ange-ftp-delete-file)
3800 (put 'read-file-name-internal 'ange-ftp 'ange-ftp-read-file-name-internal)
3801 (put 'verify-visited-file-modtime 'ange-ftp
3802 'ange-ftp-verify-visited-file-modtime)
3803 (put 'file-exists-p 'ange-ftp 'ange-ftp-file-exists-p)
3804 (put 'write-region 'ange-ftp 'ange-ftp-write-region)
3805 (put 'backup-buffer 'ange-ftp 'ange-ftp-backup-buffer)
3806 (put 'copy-file 'ange-ftp 'ange-ftp-copy-file)
3807 (put 'rename-file 'ange-ftp 'ange-ftp-rename-file)
3808 (put 'file-attributes 'ange-ftp 'ange-ftp-file-attributes)
3809 (put 'file-name-all-completions 'ange-ftp 'ange-ftp-file-name-all-completions)
3810 (put 'file-name-completion 'ange-ftp 'ange-ftp-file-name-completion)
3811 (put 'insert-directory 'ange-ftp 'ange-ftp-insert-directory)
3812 (put 'file-local-copy 'ange-ftp 'ange-ftp-file-local-copy)
3813 (put 'unhandled-file-name-directory 'ange-ftp
3814 'ange-ftp-unhandled-file-name-directory)
3815 (put 'file-name-sans-versions 'ange-ftp 'ange-ftp-file-name-sans-versions)
3816 (put 'dired-uncache 'ange-ftp 'ange-ftp-dired-uncache)
3817 (put 'dired-compress-file 'ange-ftp 'ange-ftp-dired-compress-file)
3818 (put 'load 'ange-ftp 'ange-ftp-load)
3820 ;; Turn off truename processing to save time.
3821 ;; Treat each name as its own truename.
3822 (put 'file-truename 'ange-ftp 'identity)
3824 ;; Turn off RCS/SCCS processing to save time.
3825 ;; This returns nil for any file name as argument.
3826 (put 'vc-registered 'ange-ftp 'null)
3828 ;;; Define ways of getting at unmodified Emacs primitives,
3829 ;;; turning off our handler.
3831 (defun ange-ftp-real-file-name-directory (&rest args)
3832 (let (file-name-handler-alist)
3833 (apply 'file-name-directory args)))
3834 (defun ange-ftp-real-file-name-nondirectory (&rest args)
3835 (let (file-name-handler-alist)
3836 (apply 'file-name-nondirectory args)))
3837 (defun ange-ftp-real-file-name-as-directory (&rest args)
3838 (let (file-name-handler-alist)
3839 (apply 'file-name-as-directory args)))
3840 (defun ange-ftp-real-directory-file-name (&rest args)
3841 (let (file-name-handler-alist)
3842 (apply 'directory-file-name args)))
3843 (defun ange-ftp-real-expand-file-name (&rest args)
3844 (let (file-name-handler-alist)
3845 (apply 'expand-file-name args)))
3846 (defun ange-ftp-real-make-directory (&rest args)
3847 (let (file-name-handler-alist)
3848 (apply 'make-directory args)))
3849 (defun ange-ftp-real-delete-directory (&rest args)
3850 (let (file-name-handler-alist)
3851 (apply 'delete-directory args)))
3852 (defun ange-ftp-real-insert-file-contents (&rest args)
3853 (let (file-name-handler-alist)
3854 (apply 'insert-file-contents args)))
3855 (defun ange-ftp-real-directory-files (&rest args)
3856 (let (file-name-handler-alist)
3857 (apply 'directory-files args)))
3858 (defun ange-ftp-real-file-directory-p (&rest args)
3859 (let (file-name-handler-alist)
3860 (apply 'file-directory-p args)))
3861 (defun ange-ftp-real-file-writable-p (&rest args)
3862 (let (file-name-handler-alist)
3863 (apply 'file-writable-p args)))
3864 (defun ange-ftp-real-file-readable-p (&rest args)
3865 (let (file-name-handler-alist)
3866 (apply 'file-readable-p args)))
3867 (defun ange-ftp-real-file-executable-p (&rest args)
3868 (let (file-name-handler-alist)
3869 (apply 'file-executable-p args)))
3870 (defun ange-ftp-real-file-symlink-p (&rest args)
3871 (let (file-name-handler-alist)
3872 (apply 'file-symlink-p args)))
3873 (defun ange-ftp-real-delete-file (&rest args)
3874 (let (file-name-handler-alist)
3875 (apply 'delete-file args)))
3876 (defun ange-ftp-real-read-file-name-internal (&rest args)
3877 (let (file-name-handler-alist)
3878 (apply 'read-file-name-internal args)))
3879 (defun ange-ftp-real-verify-visited-file-modtime (&rest args)
3880 (let (file-name-handler-alist)
3881 (apply 'verify-visited-file-modtime args)))
3882 (defun ange-ftp-real-file-exists-p (&rest args)
3883 (let (file-name-handler-alist)
3884 (apply 'file-exists-p args)))
3885 (defun ange-ftp-real-write-region (&rest args)
3886 (let (file-name-handler-alist)
3887 (apply 'write-region args)))
3888 (defun ange-ftp-real-backup-buffer (&rest args)
3889 (let (file-name-handler-alist)
3890 (apply 'backup-buffer args)))
3891 (defun ange-ftp-real-copy-file (&rest args)
3892 (let (file-name-handler-alist)
3893 (apply 'copy-file args)))
3894 (defun ange-ftp-real-rename-file (&rest args)
3895 (let (file-name-handler-alist)
3896 (apply 'rename-file args)))
3897 (defun ange-ftp-real-file-attributes (&rest args)
3898 (let (file-name-handler-alist)
3899 (apply 'file-attributes args)))
3900 (defun ange-ftp-real-file-name-all-completions (&rest args)
3901 (let (file-name-handler-alist)
3902 (apply 'file-name-all-completions args)))
3903 (defun ange-ftp-real-file-name-completion (&rest args)
3904 (let (file-name-handler-alist)
3905 (apply 'file-name-completion args)))
3906 (defun ange-ftp-real-insert-directory (&rest args)
3907 (let (file-name-handler-alist)
3908 (apply 'insert-directory args)))
3909 (defun ange-ftp-real-file-name-sans-versions (&rest args)
3910 (let (file-name-handler-alist)
3911 (apply 'file-name-sans-versions args)))
3912 (defun ange-ftp-real-shell-command (&rest args)
3913 (let (file-name-handler-alist)
3914 (apply 'shell-command args)))
3915 (defun ange-ftp-real-load (&rest args)
3916 (let (file-name-handler-alist)
3917 (apply 'load args)))
3919 ;; Here we support using dired on remote hosts.
3920 ;; I have turned off the support for using dired on foreign directory formats.
3921 ;; That involves too many unclean hooks.
3922 ;; It would be cleaner to support such operations by
3923 ;; converting the foreign directory format to something dired can understand;
3924 ;; something close to ls -l output.
3925 ;; The logical place to do this is in the functions ange-ftp-parse-...-listing.
3927 ;; Some of the old dired hooks would still be needed even if this is done.
3928 ;; I have preserved (and modernized) those hooks.
3929 ;; So the format conversion should be all that is needed.
3931 (defun ange-ftp-insert-directory (file switches &optional wildcard full)
3932 (let ((short (ange-ftp-abbreviate-filename file))
3933 (parsed (ange-ftp-ftp-name file)))
3934 (if parsed
3935 (insert
3936 (if wildcard
3937 (let ((default-directory (file-name-directory file)))
3938 (ange-ftp-ls (file-name-nondirectory file) switches nil nil t))
3939 (ange-ftp-ls file switches full)))
3940 (ange-ftp-real-insert-directory file switches wildcard full))))
3942 (defun ange-ftp-dired-uncache (dir)
3943 (if (ange-ftp-ftp-name (expand-file-name dir)))
3944 (setq ange-ftp-ls-cache-file nil))
3946 (defvar ange-ftp-sans-version-alist nil
3947 "Alist of mapping host type into function to remove file version numbers.")
3949 (defun ange-ftp-file-name-sans-versions (file keep-backup-version)
3950 (setq file (ange-ftp-abbreviate-filename file))
3951 (let ((parsed (ange-ftp-ftp-name file))
3952 host-type func)
3953 (if parsed
3954 (setq host-type (ange-ftp-host-type (car parsed))
3955 func (cdr (assq (ange-ftp-host-type (car parsed))
3956 ange-ftp-sans-version-alist))))
3957 (if func (funcall func file keep-backup-version)
3958 (ange-ftp-real-file-name-sans-versions file keep-backup-version))))
3960 (defvar ange-ftp-remote-shell-file-name
3961 (if (memq system-type '(hpux usg-unix-v)) ; hope that's right
3962 "remsh"
3963 "rsh")
3964 "Name of command to run a remote shell, for ange-ftp.")
3966 ;;; This doesn't work yet; a new hook needs to be created.
3967 ;;; Maybe the new hook should be in call-process.
3968 (defun ange-ftp-shell-command (command)
3969 (let* ((parsed (ange-ftp-ftp-name default-directory))
3970 (host (nth 0 parsed))
3971 (user (nth 1 parsed))
3972 (name (nth 2 parsed)))
3973 (if (not parsed)
3974 (ange-ftp-real-shell-command command)
3975 (if (> (length name) 0) ; else it's $HOME
3976 (setq command (concat "cd " name "; " command)))
3977 (setq command
3978 (format "%s %s \"%s\"" ; remsh -l USER does not work well
3979 ; on a hp-ux machine I tried
3980 ange-ftp-remote-shell-file-name host command))
3981 (ange-ftp-message "Remote command '%s' ..." command)
3982 ;; Cannot call ange-ftp-real-dired-run-shell-command here as it
3983 ;; would prepend "cd default-directory" --- which bombs because
3984 ;; default-directory is in ange-ftp syntax for remote file names.
3985 (ange-ftp-real-shell-command command))))
3987 ;;; Thisis not hooked up yet.
3988 (defun ange-ftp-dired-call-process (program discard &rest arguments)
3989 ;; PROGRAM is always one of those below in the cond in dired.el.
3990 ;; The ARGUMENTS are (nearly) always files.
3991 (if (ange-ftp-ftp-name default-directory)
3992 ;; Can't use ange-ftp-dired-host-type here because the current
3993 ;; buffer is *dired-check-process output*
3994 (condition-case oops
3995 (cond ((equal "chmod" program)
3996 (ange-ftp-call-chmod arguments))
3997 ;; ((equal "chgrp" program))
3998 ;; ((equal dired-chown-program program))
3999 (t (error "Unknown remote command: %s" program)))
4000 (ftp-error (insert (format "%s: %s, %s\n"
4001 (nth 1 oops)
4002 (nth 2 oops)
4003 (nth 3 oops))))
4004 (error (insert (format "%s\n" (nth 1 oops)))))
4005 (apply 'call-process program nil (not discard) nil arguments)))
4007 ;;; This currently does not work; it is never called.
4008 (defun ange-ftp-call-chmod (args)
4009 (if (< (length args) 2)
4010 (error "ange-ftp-call-chmod: missing mode and/or filename: %s" args))
4011 (let ((mode (car args)))
4012 (mapcar
4013 (function
4014 (lambda (file)
4015 (setq file (expand-file-name file))
4016 (let ((parsed (ange-ftp-ftp-name file)))
4017 (if parsed
4018 (let* ((host (nth 0 parsed))
4019 (user (nth 1 parsed))
4020 (name (ange-ftp-quote-string (nth 2 parsed)))
4021 (abbr (ange-ftp-abbreviate-filename file))
4022 (result (ange-ftp-send-cmd host user
4023 (list 'chmod mode name)
4024 (format "doing chmod %s"
4025 abbr))))
4026 (or (car result)
4027 (ange-ftp-error host user
4028 (format "chmod: %s: \"%s\""
4029 file
4030 (cdr result)))))))))
4031 (cdr args)))
4032 (setq ange-ftp-ls-cache-file nil)) ;stop confusing dired
4034 ;;; This is turned off because it has nothing properly to do
4035 ;;; with dired. It could be reasonable to adapt this to
4036 ;;; replace ange-ftp-copy-file.
4038 ;;;;; ------------------------------------------------------------
4039 ;;;;; Noddy support for async copy-file within dired.
4040 ;;;;; ------------------------------------------------------------
4042 ;;(defun ange-ftp-dired-copy-file (from to ok-flag &optional cont nowait)
4043 ;; "Documented as original."
4044 ;; (dired-handle-overwrite to)
4045 ;; (ange-ftp-copy-file-internal from to ok-flag dired-copy-preserve-time nil
4046 ;; cont nowait))
4048 ;;(defun ange-ftp-dired-do-create-files (op-symbol file-creator operation arg
4049 ;; &optional marker-char op1
4050 ;; how-to)
4051 ;; "Documented as original."
4052 ;; ;; we need to let ange-ftp-dired-create-files know that we indirectly
4053 ;; ;; called it rather than somebody else.
4054 ;; (let ((ange-ftp-dired-do-create-files t)) ; tell who caller is
4055 ;; (ange-ftp-real-dired-do-create-files op-symbol file-creator operation
4056 ;; arg marker-char op1 how-to)))
4058 ;;(defun ange-ftp-dired-create-files (file-creator operation fn-list name-constructor
4059 ;; &optional marker-char)
4060 ;; "Documented as original."
4061 ;; (if (and (boundp 'ange-ftp-dired-do-create-files)
4062 ;; ;; called from ange-ftp-dired-do-create-files?
4063 ;; ange-ftp-dired-do-create-files
4064 ;; ;; any files worth copying?
4065 ;; fn-list
4066 ;; ;; we only support async copy-file at the mo.
4067 ;; (eq file-creator 'dired-copy-file)
4068 ;; ;; it is only worth calling the alternative function for remote files
4069 ;; ;; as we tie ourself in recursive knots otherwise.
4070 ;; (or (ange-ftp-ftp-name (car fn-list))
4071 ;; ;; we can only call the name constructor for dired-do-create-files
4072 ;; ;; since the one for regexps starts prompting here, there and
4073 ;; ;; everywhere.
4074 ;; (ange-ftp-ftp-name (funcall name-constructor (car fn-list)))))
4075 ;; ;; use the process-filter driven routine rather than the iterative one.
4076 ;; (ange-ftp-dcf-1 file-creator
4077 ;; operation
4078 ;; fn-list
4079 ;; name-constructor
4080 ;; (and (boundp 'target) target) ;dynamically bound
4081 ;; marker-char
4082 ;; (current-buffer)
4083 ;; nil ;overwrite-query
4084 ;; nil ;overwrite-backup-query
4085 ;; nil ;failures
4086 ;; nil ;skipped
4087 ;; 0 ;success-count
4088 ;; (length fn-list) ;total
4089 ;; )
4090 ;; ;; normal case... use the interactive routine... much cheaper.
4091 ;; (ange-ftp-real-dired-create-files file-creator operation fn-list
4092 ;; name-constructor marker-char)))
4094 ;;(defun ange-ftp-dcf-1 (file-creator operation fn-list name-constructor
4095 ;; target marker-char buffer overwrite-query
4096 ;; overwrite-backup-query failures skipped
4097 ;; success-count total)
4098 ;; (let ((old-buf (current-buffer)))
4099 ;; (unwind-protect
4100 ;; (progn
4101 ;; (set-buffer buffer)
4102 ;; (if (null fn-list)
4103 ;; (ange-ftp-dcf-3 failures operation total skipped
4104 ;; success-count buffer)
4106 ;; (let* ((from (car fn-list))
4107 ;; (to (funcall name-constructor from)))
4108 ;; (if (equal to from)
4109 ;; (progn
4110 ;; (setq to nil)
4111 ;; (dired-log "Cannot %s to same file: %s\n"
4112 ;; (downcase operation) from)))
4113 ;; (if (not to)
4114 ;; (ange-ftp-dcf-1 file-creator
4115 ;; operation
4116 ;; (cdr fn-list)
4117 ;; name-constructor
4118 ;; target
4119 ;; marker-char
4120 ;; buffer
4121 ;; overwrite-query
4122 ;; overwrite-backup-query
4123 ;; failures
4124 ;; (cons (dired-make-relative from) skipped)
4125 ;; success-count
4126 ;; total)
4127 ;; (let* ((overwrite (file-exists-p to))
4128 ;; (overwrite-confirmed ; for dired-handle-overwrite
4129 ;; (and overwrite
4130 ;; (let ((help-form '(format "\
4131 ;;Type SPC or `y' to overwrite file `%s',
4132 ;;DEL or `n' to skip to next,
4133 ;;ESC or `q' to not overwrite any of the remaining files,
4134 ;;`!' to overwrite all remaining files with no more questions." to)))
4135 ;; (dired-query 'overwrite-query
4136 ;; "Overwrite `%s'?" to))))
4137 ;; ;; must determine if FROM is marked before file-creator
4138 ;; ;; gets a chance to delete it (in case of a move).
4139 ;; (actual-marker-char
4140 ;; (cond ((integerp marker-char) marker-char)
4141 ;; (marker-char (dired-file-marker from)) ; slow
4142 ;; (t nil))))
4143 ;; (condition-case err
4144 ;; (funcall file-creator from to overwrite-confirmed
4145 ;; (list (function ange-ftp-dcf-2)
4146 ;; nil ;err
4147 ;; file-creator operation fn-list
4148 ;; name-constructor
4149 ;; target
4150 ;; marker-char actual-marker-char
4151 ;; buffer to from
4152 ;; overwrite
4153 ;; overwrite-confirmed
4154 ;; overwrite-query
4155 ;; overwrite-backup-query
4156 ;; failures skipped success-count
4157 ;; total)
4158 ;; t)
4159 ;; (file-error ; FILE-CREATOR aborted
4160 ;; (ange-ftp-dcf-2 nil ;result
4161 ;; nil ;line
4162 ;; err
4163 ;; file-creator operation fn-list
4164 ;; name-constructor
4165 ;; target
4166 ;; marker-char actual-marker-char
4167 ;; buffer to from
4168 ;; overwrite
4169 ;; overwrite-confirmed
4170 ;; overwrite-query
4171 ;; overwrite-backup-query
4172 ;; failures skipped success-count
4173 ;; total))))))))
4174 ;; (set-buffer old-buf))))
4176 ;;(defun ange-ftp-dcf-2 (result line err
4177 ;; file-creator operation fn-list
4178 ;; name-constructor
4179 ;; target
4180 ;; marker-char actual-marker-char
4181 ;; buffer to from
4182 ;; overwrite
4183 ;; overwrite-confirmed
4184 ;; overwrite-query
4185 ;; overwrite-backup-query
4186 ;; failures skipped success-count
4187 ;; total)
4188 ;; (let ((old-buf (current-buffer)))
4189 ;; (unwind-protect
4190 ;; (progn
4191 ;; (set-buffer buffer)
4192 ;; (if (or err (not result))
4193 ;; (progn
4194 ;; (setq failures (cons (dired-make-relative from) failures))
4195 ;; (dired-log "%s `%s' to `%s' failed:\n%s\n"
4196 ;; operation from to (or err line)))
4197 ;; (if overwrite
4198 ;; ;; If we get here, file-creator hasn't been aborted
4199 ;; ;; and the old entry (if any) has to be deleted
4200 ;; ;; before adding the new entry.
4201 ;; (dired-remove-file to))
4202 ;; (setq success-count (1+ success-count))
4203 ;; (message "%s: %d of %d" operation success-count total)
4204 ;; (dired-add-file to actual-marker-char))
4206 ;; (ange-ftp-dcf-1 file-creator operation (cdr fn-list)
4207 ;; name-constructor
4208 ;; target
4209 ;; marker-char
4210 ;; buffer
4211 ;; overwrite-query
4212 ;; overwrite-backup-query
4213 ;; failures skipped success-count
4214 ;; total))
4215 ;; (set-buffer old-buf))))
4217 ;;(defun ange-ftp-dcf-3 (failures operation total skipped success-count
4218 ;; buffer)
4219 ;; (let ((old-buf (current-buffer)))
4220 ;; (unwind-protect
4221 ;; (progn
4222 ;; (set-buffer buffer)
4223 ;; (cond
4224 ;; (failures
4225 ;; (dired-log-summary
4226 ;; (message "%s failed for %d of %d file%s %s"
4227 ;; operation (length failures) total
4228 ;; (dired-plural-s total) failures)))
4229 ;; (skipped
4230 ;; (dired-log-summary
4231 ;; (message "%s: %d of %d file%s skipped %s"
4232 ;; operation (length skipped) total
4233 ;; (dired-plural-s total) skipped)))
4234 ;; (t
4235 ;; (message "%s: %s file%s."
4236 ;; operation success-count (dired-plural-s success-count))))
4237 ;; (dired-move-to-filename))
4238 ;; (set-buffer old-buf))))
4240 ;;;; -----------------------------------------------
4241 ;;;; Unix Descriptive Listing (dl) Support
4242 ;;;; -----------------------------------------------
4244 ;; This is turned off because nothing uses it currently
4245 ;; and because I don't understand what it's supposed to be for. --rms.
4247 ;;(defconst ange-ftp-dired-dl-re-dir
4248 ;; "^. [^ /]+/[ \n]"
4249 ;; "Regular expression to use to search for dl directories.")
4251 ;;(or (assq 'unix:dl ange-ftp-dired-re-dir-alist)
4252 ;; (setq ange-ftp-dired-re-dir-alist
4253 ;; (cons (cons 'unix:dl ange-ftp-dired-dl-re-dir)
4254 ;; ange-ftp-dired-re-dir-alist)))
4256 ;;(defun ange-ftp-dired-dl-move-to-filename (&optional raise-error eol)
4257 ;; "In dired, move to the first character of the filename on this line."
4258 ;; ;; This is the Unix dl version.
4259 ;; (or eol (setq eol (progn (end-of-line) (point))))
4260 ;; (let (case-fold-search)
4261 ;; (beginning-of-line)
4262 ;; (if (looking-at ". [^ ]+ +\\([0-9]+\\|-\\|=\\) ")
4263 ;; (goto-char (+ (point) 2))
4264 ;; (if raise-error
4265 ;; (error "No file on this line")
4266 ;; nil))))
4268 ;;(or (assq 'unix:dl ange-ftp-dired-move-to-filename-alist)
4269 ;; (setq ange-ftp-dired-move-to-filename-alist
4270 ;; (cons '(unix:dl . ange-ftp-dired-dl-move-to-filename)
4271 ;; ange-ftp-dired-move-to-filename-alist)))
4273 ;;(defun ange-ftp-dired-dl-move-to-end-of-filename (&optional no-error eol)
4274 ;; ;; Assumes point is at beginning of filename.
4275 ;; ;; So, it should be called only after (dired-move-to-filename t).
4276 ;; ;; On failure, signals an error or returns nil.
4277 ;; ;; This is the Unix dl version.
4278 ;; (let ((opoint (point))
4279 ;; case-fold-search hidden)
4280 ;; (or eol (setq eol (save-excursion (end-of-line) (point))))
4281 ;; (setq hidden (and selective-display
4282 ;; (save-excursion
4283 ;; (search-forward "\r" eol t))))
4284 ;; (if hidden
4285 ;; (if no-error
4286 ;; nil
4287 ;; (error
4288 ;; (substitute-command-keys
4289 ;; "File line is hidden, type \\[dired-hide-subdir] to unhide")))
4290 ;; (skip-chars-forward "^ /" eol)
4291 ;; (if (eq opoint (point))
4292 ;; (if no-error
4293 ;; nil
4294 ;; (error "No file on this line"))
4295 ;; (point)))))
4297 ;;(or (assq 'unix:dl ange-ftp-dired-move-to-end-of-filename-alist)
4298 ;; (setq ange-ftp-dired-move-to-end-of-filename-alist
4299 ;; (cons '(unix:dl . ange-ftp-dired-dl-move-to-end-of-filename)
4300 ;; ange-ftp-dired-move-to-end-of-filename-alist)))
4302 ;;;; ------------------------------------------------------------
4303 ;;;; VOS support (VOS support is probably broken,
4304 ;;;; but I don't know anything about VOS.)
4305 ;;;; ------------------------------------------------------------
4307 ;(defun ange-ftp-fix-name-for-vos (name &optional reverse)
4308 ; (setq name (copy-sequence name))
4309 ; (let ((from (if reverse ?\> ?\/))
4310 ; (to (if reverse ?\/ ?\>))
4311 ; (i (1- (length name))))
4312 ; (while (>= i 0)
4313 ; (if (= (aref name i) from)
4314 ; (aset name i to))
4315 ; (setq i (1- i)))
4316 ; name))
4318 ;(or (assq 'vos ange-ftp-fix-name-func-alist)
4319 ; (setq ange-ftp-fix-name-func-alist
4320 ; (cons '(vos . ange-ftp-fix-name-for-vos)
4321 ; ange-ftp-fix-name-func-alist)))
4323 ;(or (memq 'vos ange-ftp-dumb-host-types)
4324 ; (setq ange-ftp-dumb-host-types
4325 ; (cons 'vos ange-ftp-dumb-host-types)))
4327 ;(defun ange-ftp-fix-dir-name-for-vos (dir-name)
4328 ; (ange-ftp-fix-name-for-vos
4329 ; (concat dir-name
4330 ; (if (eq ?/ (aref dir-name (1- (length dir-name))))
4331 ; "" "/")
4332 ; "*")))
4334 ;(or (assq 'vos ange-ftp-fix-dir-name-func-alist)
4335 ; (setq ange-ftp-fix-dir-name-func-alist
4336 ; (cons '(vos . ange-ftp-fix-dir-name-for-vos)
4337 ; ange-ftp-fix-dir-name-func-alist)))
4339 ;(defvar ange-ftp-vos-host-regexp nil
4340 ; "If a host matches this regexp then it is assumed to be running VOS.")
4342 ;(defun ange-ftp-vos-host (host)
4343 ; (and ange-ftp-vos-host-regexp
4344 ; (ange-ftp-save-match-data
4345 ; (string-match ange-ftp-vos-host-regexp host))))
4347 ;(defun ange-ftp-parse-vos-listing ()
4348 ; "Parse the current buffer which is assumed to be in VOS list -all
4349 ;format, and return a hashtable as the result."
4350 ; (let ((tbl (ange-ftp-make-hashtable))
4351 ; (type-list
4352 ; '(("^Files: [0-9]+ +Blocks: [0-9]+\n+" nil 40)
4353 ; ("^Dirs: [0-9]+\n+" t 30)))
4354 ; type-regexp type-is-dir type-col file)
4355 ; (goto-char (point-min))
4356 ; (ange-ftp-save-match-data
4357 ; (while type-list
4358 ; (setq type-regexp (car (car type-list))
4359 ; type-is-dir (nth 1 (car type-list))
4360 ; type-col (nth 2 (car type-list))
4361 ; type-list (cdr type-list))
4362 ; (if (re-search-forward type-regexp nil t)
4363 ; (while (eq (char-after (point)) ? )
4364 ; (move-to-column type-col)
4365 ; (setq file (buffer-substring (point)
4366 ; (progn
4367 ; (end-of-line 1)
4368 ; (point))))
4369 ; (ange-ftp-put-hash-entry file type-is-dir tbl)
4370 ; (forward-line 1))))
4371 ; (ange-ftp-put-hash-entry "." 'vosdir tbl)
4372 ; (ange-ftp-put-hash-entry ".." 'vosdir tbl))
4373 ; tbl))
4375 ;(or (assq 'vos ange-ftp-parse-list-func-alist)
4376 ; (setq ange-ftp-parse-list-func-alist
4377 ; (cons '(vos . ange-ftp-parse-vos-listing)
4378 ; ange-ftp-parse-list-func-alist)))
4380 ;;;; ------------------------------------------------------------
4381 ;;;; VMS support.
4382 ;;;; ------------------------------------------------------------
4384 ;; Convert NAME from UNIX-ish to VMS. If REVERSE given then convert from VMS
4385 ;; to UNIX-ish.
4386 (defun ange-ftp-fix-name-for-vms (name &optional reverse)
4387 (ange-ftp-save-match-data
4388 (if reverse
4389 (if (string-match "^\\([^:]+:\\)?\\(\\[.*\\]\\)?\\([^][]*\\)$" name)
4390 (let (drive dir file)
4391 (if (match-beginning 1)
4392 (setq drive (substring name
4393 (match-beginning 1)
4394 (match-end 1))))
4395 (if (match-beginning 2)
4396 (setq dir
4397 (substring name (match-beginning 2) (match-end 2))))
4398 (if (match-beginning 3)
4399 (setq file
4400 (substring name (match-beginning 3) (match-end 3))))
4401 (and dir
4402 (setq dir (apply (function concat)
4403 (mapcar (function
4404 (lambda (char)
4405 (if (= char ?.)
4406 (vector ?/)
4407 (vector char))))
4408 (substring dir 1 -1)))))
4409 (concat (and drive
4410 (concat "/" drive "/"))
4411 dir (and dir "/")
4412 file))
4413 (error "name %s didn't match" name))
4414 (let (drive dir file tmp)
4415 (if (string-match "^/[^:]+:/" name)
4416 (setq drive (substring name 1
4417 (1- (match-end 0)))
4418 name (substring name (match-end 0))))
4419 (setq tmp (file-name-directory name))
4420 (if tmp
4421 (setq dir (apply (function concat)
4422 (mapcar (function
4423 (lambda (char)
4424 (if (= char ?/)
4425 (vector ?.)
4426 (vector char))))
4427 (substring tmp 0 -1)))))
4428 (setq file (file-name-nondirectory name))
4429 (concat drive
4430 (and dir (concat "[" (if drive nil ".") dir "]"))
4431 file)))))
4433 ;; (ange-ftp-fix-name-for-vms "/PUB$:/ANONYMOUS/SDSCPUB/NEXT/Readme.txt;1")
4434 ;; (ange-ftp-fix-name-for-vms "/PUB$:[ANONYMOUS.SDSCPUB.NEXT]Readme.txt;1" t)
4436 (or (assq 'vms ange-ftp-fix-name-func-alist)
4437 (setq ange-ftp-fix-name-func-alist
4438 (cons '(vms . ange-ftp-fix-name-for-vms)
4439 ange-ftp-fix-name-func-alist)))
4441 (or (memq 'vms ange-ftp-dumb-host-types)
4442 (setq ange-ftp-dumb-host-types
4443 (cons 'vms ange-ftp-dumb-host-types)))
4445 ;; It is important that this function barf for directories for which we know
4446 ;; that we cannot possibly get a directory listing, such as "/" and "/DEV:/".
4447 ;; This is because it saves an unnecessary FTP error, or possibly the listing
4448 ;; might succeed, but give erroneous info. This last case is particularly
4449 ;; likely for OS's (like MTS) for which we need to use a wildcard in order
4450 ;; to list a directory.
4452 ;; Convert name from UNIX-ish to VMS ready for a DIRectory listing.
4453 (defun ange-ftp-fix-dir-name-for-vms (dir-name)
4454 ;; Should there be entries for .. -> [-] and . -> [] below. Don't
4455 ;; think so, because expand-filename should have already short-circuited
4456 ;; them.
4457 (cond ((string-equal dir-name "/")
4458 (error "Cannot get listing for fictitious \"/\" directory."))
4459 ((string-match "^/[-A-Z0-9_$]+:/$" dir-name)
4460 (error "Cannot get listing for device."))
4461 ((ange-ftp-fix-name-for-vms dir-name))))
4463 (or (assq 'vms ange-ftp-fix-dir-name-func-alist)
4464 (setq ange-ftp-fix-dir-name-func-alist
4465 (cons '(vms . ange-ftp-fix-dir-name-for-vms)
4466 ange-ftp-fix-dir-name-func-alist)))
4468 (defvar ange-ftp-vms-host-regexp nil)
4470 ;; Return non-nil if HOST is running VMS.
4471 (defun ange-ftp-vms-host (host)
4472 (and ange-ftp-vms-host-regexp
4473 (ange-ftp-save-match-data
4474 (string-match ange-ftp-vms-host-regexp host))))
4476 ;; Because some VMS ftp servers convert filenames to lower case
4477 ;; we allow a-z in the filename regexp. I'm not too happy about this.
4479 (defconst ange-ftp-vms-filename-regexp
4480 (concat
4481 "\\(\\([_A-Za-z0-9$]?\\|[_A-Za-z0-9$][_A-Za-z0-9$---]*\\)\\."
4482 "[_A-Za-z0-9$---]*;+[0-9]*\\)")
4483 "Regular expression to match for a valid VMS file name in Dired buffer.
4484 Stupid freaking bug! Position of _ and $ shouldn't matter but they do.
4485 Having [A-Z0-9$_] bombs on filename _$$CHANGE_LOG$.TXT$ and $CHANGE_LOG$.TX
4486 Other orders of $ and _ seem to all work just fine.")
4488 ;; These parsing functions are as general as possible because the syntax
4489 ;; of ftp listings from VMS hosts is a bit erratic. What saves us is that
4490 ;; the VMS filename syntax is so rigid. If they bomb on a listing in the
4491 ;; standard VMS Multinet format, then this is a bug. If they bomb on a listing
4492 ;; from vms.weird.net, then too bad.
4494 ;; Extract the next filename from a VMS dired-like listing.
4495 (defun ange-ftp-parse-vms-filename ()
4496 (if (re-search-forward
4497 ange-ftp-vms-filename-regexp
4498 nil t)
4499 (buffer-substring (match-beginning 0) (match-end 0))))
4501 ;; Parse the current buffer which is assumed to be in MultiNet FTP dir
4502 ;; format, and return a hashtable as the result.
4503 (defun ange-ftp-parse-vms-listing ()
4504 (let ((tbl (ange-ftp-make-hashtable))
4505 file)
4506 (goto-char (point-min))
4507 (ange-ftp-save-match-data
4508 (while (setq file (ange-ftp-parse-vms-filename))
4509 (if (string-match "\\.\\(DIR\\|dir\\);[0-9]+" file)
4510 ;; deal with directories
4511 (ange-ftp-put-hash-entry
4512 (substring file 0 (match-beginning 0)) t tbl)
4513 (ange-ftp-put-hash-entry file nil tbl)
4514 (if (string-match ";[0-9]+$" file) ; deal with extension
4515 ;; sans extension
4516 (ange-ftp-put-hash-entry
4517 (substring file 0 (match-beginning 0)) nil tbl)))
4518 (forward-line 1))
4519 ;; Would like to look for a "Total" line, or a "Directory" line to
4520 ;; make sure that the listing isn't complete garbage before putting
4521 ;; in "." and "..", but we can't even count on all VAX's giving us
4522 ;; either of these.
4523 (ange-ftp-put-hash-entry "." t tbl)
4524 (ange-ftp-put-hash-entry ".." t tbl))
4525 tbl))
4527 (or (assq 'vms ange-ftp-parse-list-func-alist)
4528 (setq ange-ftp-parse-list-func-alist
4529 (cons '(vms . ange-ftp-parse-vms-listing)
4530 ange-ftp-parse-list-func-alist)))
4532 ;; This version only deletes file entries which have
4533 ;; explicit version numbers, because that is all VMS allows.
4535 ;; Can the following two functions be speeded up using file
4536 ;; completion functions?
4538 (defun ange-ftp-vms-delete-file-entry (name &optional dir-p)
4539 (if dir-p
4540 (ange-ftp-internal-delete-file-entry name t)
4541 (ange-ftp-save-match-data
4542 (let ((file (ange-ftp-get-file-part name)))
4543 (if (string-match ";[0-9]+$" file)
4544 ;; In VMS you can't delete a file without an explicit
4545 ;; version number, or wild-card (e.g. FOO;*)
4546 ;; For now, we give up on wildcards.
4547 (let ((files (ange-ftp-get-hash-entry
4548 (file-name-directory name)
4549 ange-ftp-files-hashtable)))
4550 (if files
4551 (let* ((root (substring file 0
4552 (match-beginning 0)))
4553 (regexp (concat "^"
4554 (regexp-quote root)
4555 ";[0-9]+$"))
4556 versions)
4557 (ange-ftp-del-hash-entry file files)
4558 ;; Now we need to check if there are any
4559 ;; versions left. If not, then delete the
4560 ;; root entry.
4561 (mapatoms
4562 '(lambda (sym)
4563 (and (string-match regexp (get sym 'key))
4564 (setq versions t)))
4565 files)
4566 (or versions
4567 (ange-ftp-del-hash-entry root files))))))))))
4569 (or (assq 'vms ange-ftp-delete-file-entry-alist)
4570 (setq ange-ftp-delete-file-entry-alist
4571 (cons '(vms . ange-ftp-vms-delete-file-entry)
4572 ange-ftp-delete-file-entry-alist)))
4574 (defun ange-ftp-vms-add-file-entry (name &optional dir-p)
4575 (if dir-p
4576 (ange-ftp-internal-add-file-entry name t)
4577 (let ((files (ange-ftp-get-hash-entry
4578 (file-name-directory name)
4579 ange-ftp-files-hashtable)))
4580 (if files
4581 (let ((file (ange-ftp-get-file-part name)))
4582 (ange-ftp-save-match-data
4583 (if (string-match ";[0-9]+$" file)
4584 (ange-ftp-put-hash-entry
4585 (substring file 0 (match-beginning 0))
4586 nil files)
4587 ;; Need to figure out what version of the file
4588 ;; is being added.
4589 (let ((regexp (concat "^"
4590 (regexp-quote file)
4591 ";\\([0-9]+\\)$"))
4592 (version 0))
4593 (mapatoms
4594 '(lambda (sym)
4595 (let ((name (get sym 'key)))
4596 (and (string-match regexp name)
4597 (setq version
4598 (max version
4599 (string-to-int
4600 (substring name
4601 (match-beginning 1)
4602 (match-end 1))))))))
4603 files)
4604 (setq version (1+ version))
4605 (ange-ftp-put-hash-entry
4606 (concat file ";" (int-to-string version))
4607 nil files))))
4608 (ange-ftp-put-hash-entry file nil files))))))
4610 (or (assq 'vms ange-ftp-add-file-entry-alist)
4611 (setq ange-ftp-add-file-entry-alist
4612 (cons '(vms . ange-ftp-vms-add-file-entry)
4613 ange-ftp-add-file-entry-alist)))
4616 (defun ange-ftp-add-vms-host (host)
4617 "Mark HOST as the name of a machine running VMS."
4618 (interactive
4619 (list (read-string "Host: "
4620 (let ((name (or (buffer-file-name) default-directory)))
4621 (and name (car (ange-ftp-ftp-name name)))))))
4622 (if (not (ange-ftp-vms-host host))
4623 (setq ange-ftp-vms-host-regexp
4624 (concat "^" (regexp-quote host) "$"
4625 (and ange-ftp-vms-host-regexp "\\|")
4626 ange-ftp-vms-host-regexp)
4627 ange-ftp-host-cache nil)))
4630 (defun ange-ftp-vms-file-name-as-directory (name)
4631 (ange-ftp-save-match-data
4632 (if (string-match "\\.\\(DIR\\|dir\\)\\(;[0-9]+\\)?$" name)
4633 (setq name (substring name 0 (match-beginning 0))))
4634 (ange-ftp-real-file-name-as-directory name)))
4636 (or (assq 'vms ange-ftp-file-name-as-directory-alist)
4637 (setq ange-ftp-file-name-as-directory-alist
4638 (cons '(vms . ange-ftp-vms-file-name-as-directory)
4639 ange-ftp-file-name-as-directory-alist)))
4641 ;;; Tree dired support:
4643 ;; For this code I have borrowed liberally from Sebastian Kremer's
4644 ;; dired-vms.el
4647 ;;;; These regexps must be anchored to beginning of line.
4648 ;;;; Beware that the ftpd may put the device in front of the filename.
4650 ;;(defconst ange-ftp-dired-vms-re-exe "^. [^ \t.]+\\.\\(EXE\\|exe\\)[; ]"
4651 ;; "Regular expression to use to search for VMS executable files.")
4653 ;;(defconst ange-ftp-dired-vms-re-dir "^. [^ \t.]+\\.\\(DIR\\|dir\\)[; ]"
4654 ;; "Regular expression to use to search for VMS directories.")
4656 ;;(or (assq 'vms ange-ftp-dired-re-exe-alist)
4657 ;; (setq ange-ftp-dired-re-exe-alist
4658 ;; (cons (cons 'vms ange-ftp-dired-vms-re-exe)
4659 ;; ange-ftp-dired-re-exe-alist)))
4661 ;;(or (assq 'vms ange-ftp-dired-re-dir-alist)
4662 ;; (setq ange-ftp-dired-re-dir-alist
4663 ;; (cons (cons 'vms ange-ftp-dired-vms-re-dir)
4664 ;; ange-ftp-dired-re-dir-alist)))
4666 ;;(defun ange-ftp-dired-vms-insert-headerline (dir)
4667 ;; ;; VMS inserts a headerline. I would prefer the headerline
4668 ;; ;; to be in ange-ftp format. This version tries to
4669 ;; ;; be careful, because we can't count on a headerline
4670 ;; ;; over ftp, and we wouldn't want to delete anything
4671 ;; ;; important.
4672 ;; (save-excursion
4673 ;; (if (looking-at "^ wildcard ")
4674 ;; (forward-line 1))
4675 ;; (if (looking-at "^[ \n\t]*[^\n]+\\][ \t]*\n")
4676 ;; (delete-region (point) (match-end 0))))
4677 ;; (ange-ftp-real-dired-insert-headerline dir))
4679 ;;(or (assq 'vms ange-ftp-dired-insert-headerline-alist)
4680 ;; (setq ange-ftp-dired-insert-headerline-alist
4681 ;; (cons '(vms . ange-ftp-dired-vms-insert-headerline)
4682 ;; ange-ftp-dired-insert-headerline-alist)))
4684 ;;(defun ange-ftp-dired-vms-move-to-filename (&optional raise-error eol)
4685 ;; "In dired, move to first char of filename on this line.
4686 ;;Returns position (point) or nil if no filename on this line."
4687 ;; ;; This is the VMS version.
4688 ;; (let (case-fold-search)
4689 ;; (or eol (setq eol (progn (end-of-line) (point))))
4690 ;; (beginning-of-line)
4691 ;; (if (re-search-forward ange-ftp-vms-filename-regexp eol t)
4692 ;; (goto-char (match-beginning 1))
4693 ;; (if raise-error
4694 ;; (error "No file on this line")
4695 ;; nil))))
4697 ;;(or (assq 'vms ange-ftp-dired-move-to-filename-alist)
4698 ;; (setq ange-ftp-dired-move-to-filename-alist
4699 ;; (cons '(vms . ange-ftp-dired-vms-move-to-filename)
4700 ;; ange-ftp-dired-move-to-filename-alist)))
4702 ;;(defun ange-ftp-dired-vms-move-to-end-of-filename (&optional no-error eol)
4703 ;; ;; Assumes point is at beginning of filename.
4704 ;; ;; So, it should be called only after (dired-move-to-filename t).
4705 ;; ;; case-fold-search must be nil, at least for VMS.
4706 ;; ;; On failure, signals an error or returns nil.
4707 ;; ;; This is the VMS version.
4708 ;; (let (opoint hidden case-fold-search)
4709 ;; (setq opoint (point))
4710 ;; (or eol (setq eol (save-excursion (end-of-line) (point))))
4711 ;; (setq hidden (and selective-display
4712 ;; (save-excursion (search-forward "\r" eol t))))
4713 ;; (if hidden
4714 ;; nil
4715 ;; (re-search-forward ange-ftp-vms-filename-regexp eol t))
4716 ;; (or no-error
4717 ;; (not (eq opoint (point)))
4718 ;; (error
4719 ;; (if hidden
4720 ;; (substitute-command-keys
4721 ;; "File line is hidden, type \\[dired-hide-subdir] to unhide")
4722 ;; "No file on this line")))
4723 ;; (if (eq opoint (point))
4724 ;; nil
4725 ;; (point))))
4727 ;;(or (assq 'vms ange-ftp-dired-move-to-end-of-filename-alist)
4728 ;; (setq ange-ftp-dired-move-to-end-of-filename-alist
4729 ;; (cons '(vms . ange-ftp-dired-vms-move-to-end-of-filename)
4730 ;; ange-ftp-dired-move-to-end-of-filename-alist)))
4732 ;;(defun ange-ftp-dired-vms-between-files ()
4733 ;; (save-excursion
4734 ;; (beginning-of-line)
4735 ;; (or (equal (following-char) 10) ; newline
4736 ;; (equal (following-char) 9) ; tab
4737 ;; (progn (forward-char 2)
4738 ;; (or (looking-at "Total of")
4739 ;; (equal (following-char) 32))))))
4741 ;;(or (assq 'vms ange-ftp-dired-between-files-alist)
4742 ;; (setq ange-ftp-dired-between-files-alist
4743 ;; (cons '(vms . ange-ftp-dired-vms-between-files)
4744 ;; ange-ftp-dired-between-files-alist)))
4746 ;; Beware! In VMS filenames must be of the form "FILE.TYPE".
4747 ;; Therefore, we cannot just append a ".Z" to filenames for
4748 ;; compressed files. Instead, we turn "FILE.TYPE" into
4749 ;; "FILE.TYPE-Z". Hope that this is a reasonable thing to do.
4751 (defun ange-ftp-vms-make-compressed-filename (name &optional reverse)
4752 (cond
4753 ((string-match "-Z;[0-9]+$" name)
4754 (list nil (substring name 0 (match-beginning 0))))
4755 ((string-match ";[0-9]+$" name)
4756 (list nil (substring name 0 (match-beginning 0))))
4757 ((string-match "-Z$" name)
4758 (list nil (substring name 0 -2)))
4760 (list t
4761 (if (string-match ";[0-9]+$" name)
4762 (concat (substring name 0 (match-beginning 0))
4763 "-Z")
4764 (concat name "-Z"))))))
4766 (or (assq 'vms ange-ftp-make-compressed-filename-alist)
4767 (setq ange-ftp-make-compressed-filename-alist
4768 (cons '(vms . ange-ftp-vms-make-compressed-filename)
4769 ange-ftp-make-compressed-filename-alist)))
4771 ;;;; When the filename is too long, VMS will use two lines to list a file
4772 ;;;; (damn them!) This will confuse dired. To solve this, need to convince
4773 ;;;; Sebastian to use a function dired-go-to-end-of-file-line, instead of
4774 ;;;; (forward-line 1). This would require a number of changes to dired.el.
4775 ;;;; If dired gets confused, revert-buffer will fix it.
4777 ;;(defun ange-ftp-dired-vms-ls-trim ()
4778 ;; (goto-char (point-min))
4779 ;; (let ((case-fold-search nil))
4780 ;; (re-search-forward ange-ftp-vms-filename-regexp))
4781 ;; (beginning-of-line)
4782 ;; (delete-region (point-min) (point))
4783 ;; (forward-line 1)
4784 ;; (delete-region (point) (point-max)))
4787 ;;(or (assq 'vms ange-ftp-dired-ls-trim-alist)
4788 ;; (setq ange-ftp-dired-ls-trim-alist
4789 ;; (cons '(vms . ange-ftp-dired-vms-ls-trim)
4790 ;; ange-ftp-dired-ls-trim-alist)))
4792 (defun ange-ftp-vms-sans-version (name)
4793 (ange-ftp-save-match-data
4794 (if (string-match ";[0-9]+$" name)
4795 (substring name 0 (match-beginning 0))
4796 name)))
4798 (or (assq 'vms ange-ftp-sans-version-alist)
4799 (setq ange-ftp-sans-version-alist
4800 (cons '(vms . ange-ftp-vms-sans-version)
4801 ange-ftp-sans-version-alist)))
4803 ;;(defvar ange-ftp-file-version-alist)
4805 ;;;;; The vms version of clean-directory has 2 more optional args
4806 ;;;;; than the usual dired version. This is so that it can be used by
4807 ;;;;; ange-ftp-dired-vms-flag-backup-files.
4809 ;;(defun ange-ftp-dired-vms-clean-directory (keep &optional marker msg)
4810 ;; "Flag numerical backups for deletion.
4811 ;;Spares `dired-kept-versions' latest versions, and `kept-old-versions' oldest.
4812 ;;Positive prefix arg KEEP overrides `dired-kept-versions';
4813 ;;Negative prefix arg KEEP overrides `kept-old-versions' with KEEP made positive.
4815 ;;To clear the flags on these files, you can use \\[dired-flag-backup-files]
4816 ;;with a prefix argument."
4817 ;;; (interactive "P") ; Never actually called interactively.
4818 ;; (setq keep (max 1 (if keep (prefix-numeric-value keep) dired-kept-versions)))
4819 ;; (let ((early-retention (if (< keep 0) (- keep) kept-old-versions))
4820 ;; ;; late-retention must NEVER be allowed to be less than 1 in VMS!
4821 ;; ;; This could wipe ALL copies of the file.
4822 ;; (late-retention (max 1 (if (<= keep 0) dired-kept-versions keep)))
4823 ;; (action (or msg "Cleaning"))
4824 ;; (ange-ftp-trample-marker (or marker dired-del-marker))
4825 ;; (ange-ftp-file-version-alist ()))
4826 ;; (message (concat action
4827 ;; " numerical backups (keeping %d late, %d old)...")
4828 ;; late-retention early-retention)
4829 ;; ;; Look at each file.
4830 ;; ;; If the file has numeric backup versions,
4831 ;; ;; put on ange-ftp-file-version-alist an element of the form
4832 ;; ;; (FILENAME . VERSION-NUMBER-LIST)
4833 ;; (dired-map-dired-file-lines (function
4834 ;; ange-ftp-dired-vms-collect-file-versions))
4835 ;; ;; Sort each VERSION-NUMBER-LIST,
4836 ;; ;; and remove the versions not to be deleted.
4837 ;; (let ((fval ange-ftp-file-version-alist))
4838 ;; (while fval
4839 ;; (let* ((sorted-v-list (cons 'q (sort (cdr (car fval)) '<)))
4840 ;; (v-count (length sorted-v-list)))
4841 ;; (if (> v-count (+ early-retention late-retention))
4842 ;; (rplacd (nthcdr early-retention sorted-v-list)
4843 ;; (nthcdr (- v-count late-retention)
4844 ;; sorted-v-list)))
4845 ;; (rplacd (car fval)
4846 ;; (cdr sorted-v-list)))
4847 ;; (setq fval (cdr fval))))
4848 ;; ;; Look at each file. If it is a numeric backup file,
4849 ;; ;; find it in a VERSION-NUMBER-LIST and maybe flag it for deletion.
4850 ;; (dired-map-dired-file-lines
4851 ;; (function
4852 ;; ange-ftp-dired-vms-trample-file-versions mark))
4853 ;; (message (concat action " numerical backups...done"))))
4855 ;;(or (assq 'vms ange-ftp-dired-clean-directory-alist)
4856 ;; (setq ange-ftp-dired-clean-directory-alist
4857 ;; (cons '(vms . ange-ftp-dired-vms-clean-directory)
4858 ;; ange-ftp-dired-clean-directory-alist)))
4860 ;;(defun ange-ftp-dired-vms-collect-file-versions (fn)
4861 ;; ;; "If it looks like file FN has versions, return a list of the versions.
4862 ;; ;;That is a list of strings which are file names.
4863 ;; ;;The caller may want to flag some of these files for deletion."
4864 ;;(let ((name (nth 2 (ange-ftp-ftp-name fn))))
4865 ;; (if (string-match ";[0-9]+$" name)
4866 ;; (let* ((name (substring name 0 (match-beginning 0)))
4867 ;; (fn (ange-ftp-replace-name-component fn name)))
4868 ;; (if (not (assq fn ange-ftp-file-version-alist))
4869 ;; (let* ((base-versions
4870 ;; (concat (file-name-nondirectory name) ";"))
4871 ;; (bv-length (length base-versions))
4872 ;; (possibilities (file-name-all-completions
4873 ;; base-versions
4874 ;; (file-name-directory fn)))
4875 ;; (versions (mapcar
4876 ;; '(lambda (arg)
4877 ;; (if (and (string-match
4878 ;; "[0-9]+$" arg bv-length)
4879 ;; (= (match-beginning 0) bv-length))
4880 ;; (string-to-int (substring arg bv-length))
4881 ;; 0))
4882 ;; possibilities)))
4883 ;; (if versions
4884 ;; (setq
4885 ;; ange-ftp-file-version-alist
4886 ;; (cons (cons fn versions)
4887 ;; ange-ftp-file-version-alist)))))))))
4889 ;;(defun ange-ftp-dired-vms-trample-file-versions (fn)
4890 ;; (let* ((start-vn (string-match ";[0-9]+$" fn))
4891 ;; base-version-list)
4892 ;; (and start-vn
4893 ;; (setq base-version-list ; there was a base version to which
4894 ;; (assoc (substring fn 0 start-vn) ; this looks like a
4895 ;; ange-ftp-file-version-alist)) ; subversion
4896 ;; (not (memq (string-to-int (substring fn (1+ start-vn)))
4897 ;; base-version-list)) ; this one doesn't make the cut
4898 ;; (progn (beginning-of-line)
4899 ;; (delete-char 1)
4900 ;; (insert ange-ftp-trample-marker)))))
4902 ;;(defun ange-ftp-dired-vms-flag-backup-files (&optional unflag-p)
4903 ;; (let ((dired-kept-versions 1)
4904 ;; (kept-old-versions 0)
4905 ;; marker msg)
4906 ;; (if unflag-p
4907 ;; (setq marker ?\040 msg "Unflagging")
4908 ;; (setq marker dired-del-marker msg "Cleaning"))
4909 ;; (ange-ftp-dired-vms-clean-directory nil marker msg)))
4911 ;;(or (assq 'vms ange-ftp-dired-flag-backup-files-alist)
4912 ;; (setq ange-ftp-dired-flag-backup-files-alist
4913 ;; (cons '(vms . ange-ftp-dired-vms-flag-backup-files)
4914 ;; ange-ftp-dired-flag-backup-files-alist)))
4916 ;;(defun ange-ftp-dired-vms-backup-diff (&optional switches)
4917 ;; (let ((file (dired-get-filename 'no-dir))
4918 ;; bak)
4919 ;; (if (and (string-match ";[0-9]+$" file)
4920 ;; ;; Find most recent previous version.
4921 ;; (let ((root (substring file 0 (match-beginning 0)))
4922 ;; (ver
4923 ;; (string-to-int (substring file (1+ (match-beginning 0)))))
4924 ;; found)
4925 ;; (setq ver (1- ver))
4926 ;; (while (and (> ver 0) (not found))
4927 ;; (setq bak (concat root ";" (int-to-string ver)))
4928 ;; (and (file-exists-p bak) (setq found t))
4929 ;; (setq ver (1- ver)))
4930 ;; found))
4931 ;; (if switches
4932 ;; (diff (expand-file-name bak) (expand-file-name file) switches)
4933 ;; (diff (expand-file-name bak) (expand-file-name file)))
4934 ;; (error "No previous version found for %s" file))))
4936 ;;(or (assq 'vms ange-ftp-dired-backup-diff-alist)
4937 ;; (setq ange-ftp-dired-backup-diff-alist
4938 ;; (cons '(vms . ange-ftp-dired-vms-backup-diff)
4939 ;; ange-ftp-dired-backup-diff-alist)))
4942 ;;;; ------------------------------------------------------------
4943 ;;;; MTS support
4944 ;;;; ------------------------------------------------------------
4947 ;; Convert NAME from UNIX-ish to MTS. If REVERSE given then convert from
4948 ;; MTS to UNIX-ish.
4949 (defun ange-ftp-fix-name-for-mts (name &optional reverse)
4950 (ange-ftp-save-match-data
4951 (if reverse
4952 (if (string-match "^\\([^:]+:\\)?\\(.*\\)$" name)
4953 (let (acct file)
4954 (if (match-beginning 1)
4955 (setq acct (substring name 0 (match-end 1))))
4956 (if (match-beginning 2)
4957 (setq file (substring name
4958 (match-beginning 2) (match-end 2))))
4959 (concat (and acct (concat "/" acct "/"))
4960 file))
4961 (error "name %s didn't match" name))
4962 (if (string-match "^/\\([^:]+:\\)/\\(.*\\)$" name)
4963 (concat (substring name 1 (match-end 1))
4964 (substring name (match-beginning 2) (match-end 2)))
4965 ;; Let's hope that mts will recognize it anyway.
4966 name))))
4968 (or (assq 'mts ange-ftp-fix-name-func-alist)
4969 (setq ange-ftp-fix-name-func-alist
4970 (cons '(mts . ange-ftp-fix-name-for-mts)
4971 ange-ftp-fix-name-func-alist)))
4973 ;; Convert name from UNIX-ish to MTS ready for a DIRectory listing.
4974 ;; Remember that there are no directories in MTS.
4975 (defun ange-ftp-fix-dir-name-for-mts (dir-name)
4976 (if (string-equal dir-name "/")
4977 (error "Cannot get listing for fictitious \"/\" directory.")
4978 (let ((dir-name (ange-ftp-fix-name-for-mts dir-name)))
4979 (cond
4980 ((string-equal dir-name "")
4981 "?")
4982 ((string-match ":$" dir-name)
4983 (concat dir-name "?"))
4984 (dir-name))))) ; It's just a single file.
4986 (or (assq 'mts ange-ftp-fix-dir-name-func-alist)
4987 (setq ange-ftp-fix-dir-name-func-alist
4988 (cons '(mts . ange-ftp-fix-dir-name-for-mts)
4989 ange-ftp-fix-dir-name-func-alist)))
4991 (or (memq 'mts ange-ftp-dumb-host-types)
4992 (setq ange-ftp-dumb-host-types
4993 (cons 'mts ange-ftp-dumb-host-types)))
4995 (defvar ange-ftp-mts-host-regexp nil)
4997 ;; Return non-nil if HOST is running MTS.
4998 (defun ange-ftp-mts-host (host)
4999 (and ange-ftp-mts-host-regexp
5000 (ange-ftp-save-match-data
5001 (string-match ange-ftp-mts-host-regexp host))))
5003 ;; Parse the current buffer which is assumed to be in mts ftp dir format.
5004 (defun ange-ftp-parse-mts-listing ()
5005 (let ((tbl (ange-ftp-make-hashtable)))
5006 (goto-char (point-min))
5007 (ange-ftp-save-match-data
5008 (while (re-search-forward ange-ftp-date-regexp nil t)
5009 (end-of-line)
5010 (skip-chars-backward " ")
5011 (let ((end (point)))
5012 (skip-chars-backward "-A-Z0-9_.!")
5013 (ange-ftp-put-hash-entry (buffer-substring (point) end) nil tbl))
5014 (forward-line 1)))
5015 ;; Don't need to bother with ..
5016 (ange-ftp-put-hash-entry "." t tbl)
5017 tbl))
5019 (or (assq 'mts ange-ftp-parse-list-func-alist)
5020 (setq ange-ftp-parse-list-func-alist
5021 (cons '(mts . ange-ftp-parse-mts-listing)
5022 ange-ftp-parse-list-func-alist)))
5024 (defun ange-ftp-add-mts-host (host)
5025 "Mark HOST as the name of a machine running MTS."
5026 (interactive
5027 (list (read-string "Host: "
5028 (let ((name (or (buffer-file-name) default-directory)))
5029 (and name (car (ange-ftp-ftp-name name)))))))
5030 (if (not (ange-ftp-mts-host host))
5031 (setq ange-ftp-mts-host-regexp
5032 (concat "^" (regexp-quote host) "$"
5033 (and ange-ftp-mts-host-regexp "\\|")
5034 ange-ftp-mts-host-regexp)
5035 ange-ftp-host-cache nil)))
5037 ;;; Tree dired support:
5039 ;;;; There aren't too many systems left that use MTS. This dired support will
5040 ;;;; work for the implementation of ftp on mtsg.ubc.ca. I hope other mts systems
5041 ;;;; implement ftp in the same way. If not, it might be necessary to make the
5042 ;;;; following more flexible.
5044 ;;(defun ange-ftp-dired-mts-move-to-filename (&optional raise-error eol)
5045 ;; "In dired, move to first char of filename on this line.
5046 ;;Returns position (point) or nil if no filename on this line."
5047 ;; ;; This is the MTS version.
5048 ;; (or eol (setq eol (progn (end-of-line) (point))))
5049 ;; (beginning-of-line)
5050 ;; (if (re-search-forward
5051 ;; ange-ftp-date-regexp eol t)
5052 ;; (progn
5053 ;; (skip-chars-forward " ") ; Eat blanks after date
5054 ;; (skip-chars-forward "0-9:" eol) ; Eat time or year
5055 ;; (skip-chars-forward " " eol) ; one space before filename
5056 ;; ;; When listing an account other than the users own account it appends
5057 ;; ;; ACCT: to the beginning of the filename. Skip over this.
5058 ;; (and (looking-at "[A-Z0-9_.]+:")
5059 ;; (goto-char (match-end 0)))
5060 ;; (point))
5061 ;; (if raise-error
5062 ;; (error "No file on this line")
5063 ;; nil)))
5065 ;;(or (assq 'mts ange-ftp-dired-move-to-filename-alist)
5066 ;; (setq ange-ftp-dired-move-to-filename-alist
5067 ;; (cons '(mts . ange-ftp-dired-mts-move-to-filename)
5068 ;; ange-ftp-dired-move-to-filename-alist)))
5070 ;;(defun ange-ftp-dired-mts-move-to-end-of-filename (&optional no-error eol)
5071 ;; ;; Assumes point is at beginning of filename.
5072 ;; ;; So, it should be called only after (dired-move-to-filename t).
5073 ;; ;; On failure, signals an error or returns nil.
5074 ;; ;; This is the MTS version.
5075 ;; (let (opoint hidden case-fold-search)
5076 ;; (setq opoint (point)
5077 ;; eol (save-excursion (end-of-line) (point))
5078 ;; hidden (and selective-display
5079 ;; (save-excursion (search-forward "\r" eol t))))
5080 ;; (if hidden
5081 ;; nil
5082 ;; (skip-chars-forward "-A-Z0-9._!" eol))
5083 ;; (or no-error
5084 ;; (not (eq opoint (point)))
5085 ;; (error
5086 ;; (if hidden
5087 ;; (substitute-command-keys
5088 ;; "File line is hidden, type \\[dired-hide-subdir] to unhide")
5089 ;; "No file on this line")))
5090 ;; (if (eq opoint (point))
5091 ;; nil
5092 ;; (point))))
5094 ;;(or (assq 'mts ange-ftp-dired-move-to-end-of-filename-alist)
5095 ;; (setq ange-ftp-dired-move-to-end-of-filename-alist
5096 ;; (cons '(mts . ange-ftp-dired-mts-move-to-end-of-filename)
5097 ;; ange-ftp-dired-move-to-end-of-filename-alist)))
5099 ;;;; ------------------------------------------------------------
5100 ;;;; CMS support
5101 ;;;; ------------------------------------------------------------
5103 ;; Since CMS doesn't have any full file name syntax, we have to fudge
5104 ;; things with cd's. We actually send too many cd's, but it's dangerous
5105 ;; to try to remember the current minidisk, because if the connection
5106 ;; is closed and needs to be reopened, we will find ourselves back in
5107 ;; the default minidisk. This is fairly likely since CMS ftp servers
5108 ;; usually close the connection after 5 minutes of inactivity.
5110 ;; Have I got the filename character set right?
5112 (defun ange-ftp-fix-name-for-cms (name &optional reverse)
5113 (ange-ftp-save-match-data
5114 (if reverse
5115 ;; Since we only convert output from a pwd in this direction,
5116 ;; we'll assume that it's a minidisk, and make it into a
5117 ;; directory file name. Note that the expand-dir-hashtable
5118 ;; stores directories without the trailing /. Is this
5119 ;; consistent?
5120 (concat "/" name)
5121 (if (string-match "^/\\([-A-Z0-9$*._]+\\)/\\([-A-Z0-9$._]+\\)?$"
5122 name)
5123 (let ((minidisk (substring name 1 (match-end 1))))
5124 (if (match-beginning 2)
5125 (let ((file (substring name (match-beginning 2)
5126 (match-end 2)))
5127 (cmd (concat "cd " minidisk))
5129 ;; Note that host and user are bound in the call
5130 ;; to ange-ftp-send-cmd
5131 (proc (ange-ftp-get-process ange-ftp-this-host
5132 ange-ftp-this-user)))
5134 ;; Must use ange-ftp-raw-send-cmd here to avoid
5135 ;; an infinite loop.
5136 (if (car (ange-ftp-raw-send-cmd proc cmd ange-ftp-this-msg))
5137 file
5138 ;; failed... try ONCE more.
5139 (setq proc (ange-ftp-get-process ange-ftp-this-host
5140 ange-ftp-this-user))
5141 (let ((result (ange-ftp-raw-send-cmd proc cmd
5142 ange-ftp-this-msg)))
5143 (if (car result)
5144 file
5145 ;; failed. give up.
5146 (ange-ftp-error ange-ftp-this-host ange-ftp-this-user
5147 (format "cd to minidisk %s failed: %s"
5148 minidisk (cdr result)))))))
5149 ;; return the minidisk
5150 minidisk))
5151 (error "Invalid CMS filename")))))
5153 (or (assq 'cms ange-ftp-fix-name-func-alist)
5154 (setq ange-ftp-fix-name-func-alist
5155 (cons '(cms . ange-ftp-fix-name-for-cms)
5156 ange-ftp-fix-name-func-alist)))
5158 (or (memq 'cms ange-ftp-dumb-host-types)
5159 (setq ange-ftp-dumb-host-types
5160 (cons 'cms ange-ftp-dumb-host-types)))
5162 ;; Convert name from UNIX-ish to CMS ready for a DIRectory listing.
5163 (defun ange-ftp-fix-dir-name-for-cms (dir-name)
5164 (cond
5165 ((string-equal "/" dir-name)
5166 (error "Cannot get listing for fictitious \"/\" directory."))
5167 ((string-match "^/\\([-A-Z0-9$*._]+\\)/\\([-A-Z0-9$._]+\\)?$" dir-name)
5168 (let* ((minidisk (substring dir-name (match-beginning 1) (match-end 1)))
5169 ;; host and user are bound in the call to ange-ftp-send-cmd
5170 (proc (ange-ftp-get-process ange-ftp-this-host ange-ftp-this-user))
5171 (cmd (concat "cd " minidisk))
5172 (file (if (match-beginning 2)
5173 ;; it's a single file
5174 (substring dir-name (match-beginning 2)
5175 (match-end 2))
5176 ;; use the wild-card
5177 "*")))
5178 (if (car (ange-ftp-raw-send-cmd proc cmd))
5179 file
5180 ;; try again...
5181 (setq proc (ange-ftp-get-process ange-ftp-this-host
5182 ange-ftp-this-user))
5183 (let ((result (ange-ftp-raw-send-cmd proc cmd)))
5184 (if (car result)
5185 file
5186 ;; give up
5187 (ange-ftp-error ange-ftp-this-host ange-ftp-this-user
5188 (format "cd to minidisk %s failed: "
5189 minidisk (cdr result))))))))
5190 (t (error "Invalid CMS file name"))))
5192 (or (assq 'cms ange-ftp-fix-dir-name-func-alist)
5193 (setq ange-ftp-fix-dir-name-func-alist
5194 (cons '(cms . ange-ftp-fix-dir-name-for-cms)
5195 ange-ftp-fix-dir-name-func-alist)))
5197 (defvar ange-ftp-cms-host-regexp nil
5198 "Regular expression to match hosts running the CMS operating system.")
5200 ;; Return non-nil if HOST is running CMS.
5201 (defun ange-ftp-cms-host (host)
5202 (and ange-ftp-cms-host-regexp
5203 (ange-ftp-save-match-data
5204 (string-match ange-ftp-cms-host-regexp host))))
5206 (defun ange-ftp-add-cms-host (host)
5207 "Mark HOST as the name of a CMS host."
5208 (interactive
5209 (list (read-string "Host: "
5210 (let ((name (or (buffer-file-name) default-directory)))
5211 (and name (car (ange-ftp-ftp-name name)))))))
5212 (if (not (ange-ftp-cms-host host))
5213 (setq ange-ftp-cms-host-regexp
5214 (concat "^" (regexp-quote host) "$"
5215 (and ange-ftp-cms-host-regexp "\\|")
5216 ange-ftp-cms-host-regexp)
5217 ange-ftp-host-cache nil)))
5219 (defun ange-ftp-parse-cms-listing ()
5220 ;; Parse the current buffer which is assumed to be a CMS directory listing.
5221 ;; If we succeed in getting a listing, then we will assume that the minidisk
5222 ;; exists. file is bound by the call to ange-ftp-ls. This doesn't work
5223 ;; because ange-ftp doesn't know that the root hashtable has only part of
5224 ;; the info. It will assume that if a minidisk isn't in it, then it doesn't
5225 ;; exist. It would be nice if completion worked for minidisks, as we
5226 ;; discover them.
5227 ; (let* ((dir-file (directory-file-name file))
5228 ; (root (file-name-directory dir-file))
5229 ; (minidisk (ange-ftp-get-file-part dir-file))
5230 ; (root-tbl (ange-ftp-get-hash-entry root ange-ftp-files-hashtable)))
5231 ; (if root-tbl
5232 ; (ange-ftp-put-hash-entry minidisk t root-tbl)
5233 ; (setq root-tbl (ange-ftp-make-hashtable))
5234 ; (ange-ftp-put-hash-entry minidisk t root-tbl)
5235 ; (ange-ftp-put-hash-entry "." t root-tbl)
5236 ; (ange-ftp-set-files root root-tbl)))
5237 ;; Now do the usual parsing
5238 (let ((tbl (ange-ftp-make-hashtable)))
5239 (goto-char (point-min))
5240 (ange-ftp-save-match-data
5241 (while
5242 (re-search-forward
5243 "^\\([-A-Z0-9$_]+\\) +\\([-A-Z0-9$_]+\\) +[VF] +[0-9]+ " nil t)
5244 (ange-ftp-put-hash-entry
5245 (concat (buffer-substring (match-beginning 1)
5246 (match-end 1))
5248 (buffer-substring (match-beginning 2)
5249 (match-end 2)))
5250 nil tbl)
5251 (forward-line 1))
5252 (ange-ftp-put-hash-entry "." t tbl))
5253 tbl))
5255 (or (assq 'cms ange-ftp-parse-list-func-alist)
5256 (setq ange-ftp-parse-list-func-alist
5257 (cons '(cms . ange-ftp-parse-cms-listing)
5258 ange-ftp-parse-list-func-alist)))
5260 ;;;;; Tree dired support:
5262 ;;(defconst ange-ftp-dired-cms-re-exe
5263 ;; "^. [-A-Z0-9$_]+ +EXEC "
5264 ;; "Regular expression to use to search for CMS executables.")
5266 ;;(or (assq 'cms ange-ftp-dired-re-exe-alist)
5267 ;; (setq ange-ftp-dired-re-exe-alist
5268 ;; (cons (cons 'cms ange-ftp-dired-cms-re-exe)
5269 ;; ange-ftp-dired-re-exe-alist)))
5272 ;;(defun ange-ftp-dired-cms-insert-headerline (dir)
5273 ;; ;; CMS has no total line, so we insert a blank line for
5274 ;; ;; aesthetics.
5275 ;; (insert "\n")
5276 ;; (forward-char -1)
5277 ;; (ange-ftp-real-dired-insert-headerline dir))
5279 ;;(or (assq 'cms ange-ftp-dired-insert-headerline-alist)
5280 ;; (setq ange-ftp-dired-insert-headerline-alist
5281 ;; (cons '(cms . ange-ftp-dired-cms-insert-headerline)
5282 ;; ange-ftp-dired-insert-headerline-alist)))
5284 ;;(defun ange-ftp-dired-cms-move-to-filename (&optional raise-error eol)
5285 ;; "In dired, move to the first char of filename on this line."
5286 ;; ;; This is the CMS version.
5287 ;; (or eol (setq eol (progn (end-of-line) (point))))
5288 ;; (let (case-fold-search)
5289 ;; (beginning-of-line)
5290 ;; (if (re-search-forward " [-A-Z0-9$_]+ +[-A-Z0-9$_]+ +[VF] +[0-9]+ " eol t)
5291 ;; (goto-char (1+ (match-beginning 0)))
5292 ;; (if raise-error
5293 ;; (error "No file on this line")
5294 ;; nil))))
5296 ;;(or (assq 'cms ange-ftp-dired-move-to-filename-alist)
5297 ;; (setq ange-ftp-dired-move-to-filename-alist
5298 ;; (cons '(cms . ange-ftp-dired-cms-move-to-filename)
5299 ;; ange-ftp-dired-move-to-filename-alist)))
5301 ;;(defun ange-ftp-dired-cms-move-to-end-of-filename (&optional no-error eol)
5302 ;; ;; Assumes point is at beginning of filename.
5303 ;; ;; So, it should be called only after (dired-move-to-filename t).
5304 ;; ;; case-fold-search must be nil, at least for VMS.
5305 ;; ;; On failure, signals an error or returns nil.
5306 ;; ;; This is the CMS version.
5307 ;; (let ((opoint (point))
5308 ;; case-fold-search hidden)
5309 ;; (or eol (setq eol (save-excursion (end-of-line) (point))))
5310 ;; (setq hidden (and selective-display
5311 ;; (save-excursion
5312 ;; (search-forward "\r" eol t))))
5313 ;; (if hidden
5314 ;; (if no-error
5315 ;; nil
5316 ;; (error
5317 ;; (substitute-command-keys
5318 ;; "File line is hidden, type \\[dired-hide-subdir] to unhide")))
5319 ;; (skip-chars-forward "-A-Z0-9$_" eol)
5320 ;; (skip-chars-forward " " eol)
5321 ;; (skip-chars-forward "-A-Z0-9$_" eol)
5322 ;; (if (eq opoint (point))
5323 ;; (if no-error
5324 ;; nil
5325 ;; (error "No file on this line"))
5326 ;; (point)))))
5328 ;;(or (assq 'cms ange-ftp-dired-move-to-end-of-filename-alist)
5329 ;; (setq ange-ftp-dired-move-to-end-of-filename-alist
5330 ;; (cons '(cms . ange-ftp-dired-cms-move-to-end-of-filename)
5331 ;; ange-ftp-dired-move-to-end-of-filename-alist)))
5333 (defun ange-ftp-cms-make-compressed-filename (name &optional reverse)
5334 (if (string-match "-Z$" name)
5335 (list nil (substring name 0 -2))
5336 (list t (concat name "-Z"))))
5338 (or (assq 'cms ange-ftp-make-compressed-filename-alist)
5339 (setq ange-ftp-make-compressed-filename-alist
5340 (cons '(cms . ange-ftp-cms-make-compressed-filename)
5341 ange-ftp-make-compressed-filename-alist)))
5343 ;;(defun ange-ftp-dired-cms-get-filename (&optional localp no-error-if-not-filep)
5344 ;; (let ((name (ange-ftp-real-dired-get-filename localp no-error-if-not-filep)))
5345 ;; (and name
5346 ;; (if (string-match "^\\([^ ]+\\) +\\([^ ]+\\)$" name)
5347 ;; (concat (substring name 0 (match-end 1))
5348 ;; "."
5349 ;; (substring name (match-beginning 2) (match-end 2)))
5350 ;; name))))
5352 ;;(or (assq 'cms ange-ftp-dired-get-filename-alist)
5353 ;; (setq ange-ftp-dired-get-filename-alist
5354 ;; (cons '(cms . ange-ftp-dired-cms-get-filename)
5355 ;; ange-ftp-dired-get-filename-alist)))
5357 ;;;; ------------------------------------------------------------
5358 ;;;; Finally provide package.
5359 ;;;; ------------------------------------------------------------
5361 (provide 'ange-ftp)
5363 ;;; ange-ftp.el ends here