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