?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid compiler errors like: error: variable 'xxx' set but not used [-Werror=unused...
[midnight-commander.git] / src / vfs / fish / fish.c
blobcabf7cdb9c075da30d13cf193015fdc5b63b0f98
1 /*
2 Virtual File System: FISH implementation for transfering files over
3 shell connections.
4
5 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6 2007, 2008, 2009, 2010, 2011
7 The Free Software Foundation, Inc.
8
9 Written by:
10 Pavel Machek, 1998
11 Michal Svec, 2000
12 Andrew Borodin <aborodin@vmail.ru>, 2010
13 Slava Zanko <slavazanko@gmail.com>, 2010
14 Ilia Maslakov <il.smind@gmail.com>, 2010
15
16 Derived from ftpfs.c.
17
18 This file is part of the Midnight Commander.
19
20 The Midnight Commander is free software: you can redistribute it
21 and/or modify it under the terms of the GNU General Public License as
22 published by the Free Software Foundation, either version 3 of the License,
23 or (at your option) any later version.
24
25 The Midnight Commander is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
29
30 You should have received a copy of the GNU General Public License
31 along with this program. If not, see <http://www.gnu.org/licenses/>.
32 */
33
34 /**
35 * \file
36 * \brief Source: Virtual File System: FISH implementation for transfering files over
37 * shell connections
38 * \author Pavel Machek
39 * \author Michal Svec
40 * \date 1998, 2000
41 *
42 * Derived from ftpfs.c
43 * Read README.fish for protocol specification.
44 *
45 * Syntax of path is: \verbatim sh://user@host[:Cr]/path \endverbatim
46 * where C means you want compressed connection,
47 * and r means you want to use rsh
48 *
49 * Namespace: fish_vfs_ops exported.
50 */
51
52 /* Define this if your ssh can take -I option */
53
54 #include <config.h>
55 #include <errno.h>
56 #include <fcntl.h>
57 #include <pwd.h>
58 #include <grp.h>
59 #include <sys/time.h> /* gettimeofday() */
60 #include <stdlib.h>
61 #include <string.h>
62 #include <inttypes.h> /* uintmax_t */
63
64 #include "lib/global.h"
65 #include "lib/tty/tty.h" /* enable/disable interrupt key */
66 #include "lib/strescape.h"
67 #include "lib/unixcompat.h"
68 #include "lib/fileloc.h"
69 #include "lib/mcconfig.h"
70
71 #include "src/execute.h" /* pre_exec, post_exec */
72
73 #include "lib/vfs/vfs.h"
74 #include "lib/vfs/utilvfs.h"
75 #include "lib/vfs/netutil.h"
76 #include "lib/vfs/xdirentry.h"
77 #include "lib/vfs/gc.h" /* vfs_stamp_create */
78
79 #include "fish.h"
80 #include "fishdef.h"
81
82 /*** global variables ****************************************************************************/
83
84 int fish_directory_timeout = 900;
85
86 /*** file scope macro definitions ****************************************************************/
87
88 #define DO_RESOLVE_SYMLINK 1
89 #define DO_OPEN 2
90 #define DO_FREE_RESOURCE 4
91
92 #define FISH_FLAG_COMPRESSED 1
93 #define FISH_FLAG_RSH 2
94
95 #define OPT_FLUSH 1
96 #define OPT_IGNORE_ERROR 2
97
98 /*
99 * Reply codes.
100 */
101 #define PRELIM 1 /* positive preliminary */
102 #define COMPLETE 2 /* positive completion */
103 #define CONTINUE 3 /* positive intermediate */
104 #define TRANSIENT 4 /* transient negative completion */
105 #define ERROR 5 /* permanent negative completion */
106
107 /* command wait_flag: */
108 #define NONE 0x00
109 #define WAIT_REPLY 0x01
110 #define WANT_STRING 0x02
111
112 /* environment flags */
113 #define FISH_HAVE_HEAD 1
114 #define FISH_HAVE_SED 2
115 #define FISH_HAVE_AWK 4
116 #define FISH_HAVE_PERL 8
117 #define FISH_HAVE_LSQ 16
118 #define FISH_HAVE_DATE_MDYT 32
119 #define FISH_HAVE_TAIL 64
120
121 #define SUP ((fish_super_data_t *) super->data)
122
123 /*** file scope type declarations ****************************************************************/
124
125 typedef struct
126 {
127 int sockr;
128 int sockw;
129 char *scr_ls;
130 char *scr_chmod;
131 char *scr_utime;
132 char *scr_exists;
133 char *scr_mkdir;
134 char *scr_unlink;
135 char *scr_chown;
136 char *scr_rmdir;
137 char *scr_ln;
138 char *scr_mv;
139 char *scr_hardlink;
140 char *scr_get;
141 char *scr_send;
142 char *scr_append;
143 char *scr_info;
144 int host_flags;
145 char *scr_env;
146 } fish_super_data_t;
147
148 typedef struct
149 {
150 off_t got;
151 off_t total;
152 gboolean append;
153 } fish_fh_data_t;
154
155 /*** file scope variables ************************************************************************/
156
157 static char reply_str[80];
158
159 static struct vfs_class vfs_fish_ops;
160
161 /*** file scope functions ************************************************************************/
162 /* --------------------------------------------------------------------------------------------- */
163
164 static char *
165 fish_load_script_from_file (const char *hostname, const char *script_name, const char *def_content)
166 {
167 char *scr_filename = NULL;
168 char *scr_content;
169 gsize scr_len = 0;
170
171 /* 1st: scan user directory */
172 scr_filename = g_build_path (PATH_SEP_STR, mc_config_get_data_path (), FISH_PREFIX, hostname,
173 script_name, (char *) NULL);
174 /* silent about user dir */
175 g_file_get_contents (scr_filename, &scr_content, &scr_len, NULL);
176 g_free (scr_filename);
177 /* 2nd: scan system dir */
178 if (scr_content == NULL)
179 {
180 scr_filename =
181 g_build_path (PATH_SEP_STR, LIBEXECDIR, FISH_PREFIX, script_name, (char *) NULL);
182 g_file_get_contents (scr_filename, &scr_content, &scr_len, NULL);
183 g_free (scr_filename);
184 }
185
186 if (scr_content != NULL)
187 return scr_content;
188
189 return g_strdup (def_content);
190 }
191
192 /* --------------------------------------------------------------------------------------------- */
193
194 static int
195 fish_decode_reply (char *s, gboolean was_garbage)
196 {
197 int code;
198
199 if (sscanf (s, "%d", &code) == 0)
200 {
201 code = 500;
202 return 5;
203 }
204 if (code < 100)
205 return was_garbage ? ERROR : (code == 0 ? COMPLETE : PRELIM);
206 return code / 100;
207 }
208
209 /* --------------------------------------------------------------------------------------------- */
210 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
211
212 static int
213 fish_get_reply (struct vfs_class *me, int sock, char *string_buf, int string_len)
214 {
215 char answer[BUF_1K];
216 gboolean was_garbage = FALSE;
217
218 while (TRUE)
219 {
220 if (!vfs_s_get_line (me, sock, answer, sizeof (answer), '\n'))
221 {
222 if (string_buf != NULL)
223 *string_buf = '\0';
224 return 4;
225 }
226
227 if (strncmp (answer, "### ", 4) == 0)
228 return fish_decode_reply (answer + 4, was_garbage ? 1 : 0);
229
230 was_garbage = TRUE;
231 if (string_buf != NULL)
232 g_strlcpy (string_buf, answer, string_len);
233 }
234 }
235
236 /* --------------------------------------------------------------------------------------------- */
237
238 static int
239 fish_command (struct vfs_class *me, struct vfs_s_super *super, int wait_reply, const char *fmt, ...)
240 {
241 va_list ap;
242 char *str;
243 ssize_t status;
244 FILE *logfile = MEDATA->logfile;
245
246 va_start (ap, fmt);
247
248 str = g_strdup_vprintf (fmt, ap);
249 va_end (ap);
250
251 if (logfile)
252 {
253 size_t ret;
254 ret = fwrite (str, strlen (str), 1, logfile);
255 ret = fflush (logfile);
256 (void) ret;
257 }
258
259 tty_enable_interrupt_key ();
260
261 status = write (SUP->sockw, str, strlen (str));
262 g_free (str);
263
264 tty_disable_interrupt_key ();
265 if (status < 0)
266 return TRANSIENT;
267
268 if (wait_reply)
269 return fish_get_reply (me, SUP->sockr,
270 (wait_reply & WANT_STRING) ? reply_str :
271 NULL, sizeof (reply_str) - 1);
272 return COMPLETE;
273 }
274
275 /* --------------------------------------------------------------------------------------------- */
276
277 static void
278 fish_free_archive (struct vfs_class *me, struct vfs_s_super *super)
279 {
280 if ((SUP->sockw != -1) || (SUP->sockr != -1))
281 {
282 vfs_print_message (_("fish: Disconnecting from %s"), super->name ? super->name : "???");
283 fish_command (me, super, NONE, "#BYE\nexit\n");
284 close (SUP->sockw);
285 close (SUP->sockr);
286 SUP->sockw = SUP->sockr = -1;
287 }
288 g_free (SUP->scr_ls);
289 g_free (SUP->scr_exists);
290 g_free (SUP->scr_mkdir);
291 g_free (SUP->scr_unlink);
292 g_free (SUP->scr_chown);
293 g_free (SUP->scr_chmod);
294 g_free (SUP->scr_utime);
295 g_free (SUP->scr_rmdir);
296 g_free (SUP->scr_ln);
297 g_free (SUP->scr_mv);
298 g_free (SUP->scr_hardlink);
299 g_free (SUP->scr_get);
300 g_free (SUP->scr_send);
301 g_free (SUP->scr_append);
302 g_free (SUP->scr_info);
303 g_free (SUP->scr_env);
304 g_free (SUP);
305 super->data = NULL;
306 }
307
308 /* --------------------------------------------------------------------------------------------- */
309
310 static void
311 fish_pipeopen (struct vfs_s_super *super, const char *path, const char *argv[])
312 {
313 int fileset1[2], fileset2[2];
314 int res;
315
316 if ((pipe (fileset1) < 0) || (pipe (fileset2) < 0))
317 vfs_die ("Cannot pipe(): %m.");
318
319 res = fork ();
320
321 if (res != 0)
322 {
323 if (res < 0)
324 vfs_die ("Cannot fork(): %m.");
325 /* We are the parent */
326 close (fileset1[0]);
327 SUP->sockw = fileset1[1];
328 close (fileset2[1]);
329 SUP->sockr = fileset2[0];
330 }
331 else
332 {
333 res = dup2 (fileset1[0], 0);
334 close (fileset1[0]);
335 close (fileset1[1]);
336 res = dup2 (fileset2[1], 1);
337 close (2);
338 /* stderr to /dev/null */
339 res = open ("/dev/null", O_WRONLY);
340 close (fileset2[0]);
341 close (fileset2[1]);
342 execvp (path, const_cast (char **, argv));
343 _exit (3);
344 }
345 }
346
347 /* --------------------------------------------------------------------------------------------- */
348
349 static char *
350 fish_set_env (int flags)
351 {
352 GString *tmp;
353
354 tmp = g_string_sized_new (250);
355 g_string_assign (tmp, "");
356
357 if ((flags & FISH_HAVE_HEAD) != 0)
358 g_string_append (tmp, "FISH_HAVE_HEAD=1 export FISH_HAVE_HEAD; ");
359
360 if ((flags & FISH_HAVE_SED) != 0)
361 g_string_append (tmp, "FISH_HAVE_SED=1 export FISH_HAVE_SED; ");
362
363 if ((flags & FISH_HAVE_AWK) != 0)
364 g_string_append (tmp, "FISH_HAVE_AWK=1 export FISH_HAVE_AWK; ");
365
366 if ((flags & FISH_HAVE_PERL) != 0)
367 g_string_append (tmp, "FISH_HAVE_PERL=1 export FISH_HAVE_PERL; ");
368
369 if ((flags & FISH_HAVE_LSQ) != 0)
370 g_string_append (tmp, "FISH_HAVE_LSQ=1 export FISH_HAVE_LSQ; ");
371
372 if ((flags & FISH_HAVE_DATE_MDYT) != 0)
373 g_string_append (tmp, "FISH_HAVE_DATE_MDYT=1 export FISH_HAVE_DATE_MDYT; ");
374
375 if ((flags & FISH_HAVE_TAIL) != 0)
376 g_string_append (tmp, "FISH_HAVE_TAIL=1 export FISH_HAVE_TAIL; ");
377
378 return g_string_free (tmp, FALSE);
379 }
380
381 /* --------------------------------------------------------------------------------------------- */
382
383 static gboolean
384 fish_info (struct vfs_class *me, struct vfs_s_super *super)
385 {
386 char buffer[BUF_8K];
387 if (fish_command (me, super, NONE, SUP->scr_info) == COMPLETE)
388 {
389 while (TRUE)
390 {
391 int res;
392
393 res = vfs_s_get_line_interruptible (me, buffer, sizeof (buffer), SUP->sockr);
394 if ((res == 0) || (res == EINTR))
395 ERRNOR (ECONNRESET, FALSE);
396 if (strncmp (buffer, "### ", 4) == 0)
397 break;
398 SUP->host_flags = atol (buffer);
399 }
400 return TRUE;
401 }
402 ERRNOR (E_PROTO, FALSE);
403 }
404
405
406 /* --------------------------------------------------------------------------------------------- */
407
408 static void
409 fish_open_archive_pipeopen (struct vfs_s_super *super)
410 {
411 char gbuf[10];
412 const char *argv[10]; /* All of 10 is used now */
413 const char *xsh = (super->path_element->port == FISH_FLAG_RSH ? "rsh" : "ssh");
414 int i = 0;
415
416 argv[i++] = xsh;
417 if (super->path_element->port == FISH_FLAG_COMPRESSED)
418 argv[i++] = "-C";
419
420 if (super->path_element->port > FISH_FLAG_RSH)
421 {
422 argv[i++] = "-p";
423 g_snprintf (gbuf, sizeof (gbuf), "%d", super->path_element->port);
424 argv[i++] = gbuf;
425 }
426
427 /*
428 * Add the user name to the ssh command line only if it was explicitly
429 * set in vfs URL. rsh/ssh will get current user by default
430 * plus we can set convenient overrides in ~/.ssh/config (explicit -l
431 * option breaks it for some)
432 */
433
434 if (super->path_element->user != NULL)
435 {
436 argv[i++] = "-l";
437 argv[i++] = super->path_element->user;
438 }
439 else
440 {
441 /* The rest of the code assumes it to be a valid username */
442 super->path_element->user = vfs_get_local_username ();
443 }
444
445 argv[i++] = super->path_element->host;
446 argv[i++] = "echo FISH:; /bin/sh";
447 argv[i++] = NULL;
448
449 fish_pipeopen (super, xsh, argv);
450 }
451
452 /* --------------------------------------------------------------------------------------------- */
453
454 static gboolean
455 fish_open_archive_talk (struct vfs_class *me, struct vfs_s_super *super)
456 {
457 char answer[2048];
458
459 printf ("\n%s\n", _("fish: Waiting for initial line..."));
460
461 if (!vfs_s_get_line (me, SUP->sockr, answer, sizeof (answer), ':'))
462 return FALSE;
463
464 if (strstr (answer, "assword") != NULL)
465 {
466 /* Currently, this does not work. ssh reads passwords from
467 /dev/tty, not from stdin :-(. */
468
469 printf ("\n%s\n", _("Sorry, we cannot do password authenticated connections for now."));
470
471 return FALSE;
472 #if 0
473 if (super->path_element->password == NULL)
474 {
475 char *p, *op;
476 p = g_strdup_printf (_("fish: Password is required for %s"), super->path_element->user);
477 op = vfs_get_password (p);
478 g_free (p);
479 if (op == NULL)
480 return FALSE;
481 super->path_element->password = op;
482
483 }
484
485 printf ("\n%s\n", _("fish: Sending password..."));
486
487 {
488 size_t str_len;
489
490 str_len = strlen (super->path_element->password);
491 if ((write (SUP.sockw, super->path_element->password, str_len) != (ssize_t) str_len)
492 || (write (SUP->sockw, "\n", 1) != 1))
493 return FALSE;
494 }
495 #endif
496 }
497 return TRUE;
498 }
499
500 /* --------------------------------------------------------------------------------------------- */
501
502 static int
503 fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
504 {
505 gboolean ftalk;
506 /* hide panels */
507 pre_exec ();
508
509 /* open pipe */
510 fish_open_archive_pipeopen (super);
511
512 /* Start talk with ssh-server (password prompt, etc ) */
513 ftalk = fish_open_archive_talk (me, super);
514
515 /* show panels */
516 post_exec ();
517
518 if (!ftalk)
519 ERRNOR (E_PROTO, -1);
520
521 vfs_print_message (_("fish: Sending initial line..."));
522 /*
523 * Run `start_fish_server'. If it doesn't exist - no problem,
524 * we'll talk directly to the shell.
525 */
526
527 if (fish_command
528 (me, super, WAIT_REPLY,
529 "#FISH\necho; start_fish_server 2>&1; echo '### 200'\n") != COMPLETE)
530 ERRNOR (E_PROTO, -1);
531
532 vfs_print_message (_("fish: Handshaking version..."));
533 if (fish_command (me, super, WAIT_REPLY, "#VER 0.0.3\necho '### 000'\n") != COMPLETE)
534 ERRNOR (E_PROTO, -1);
535
536 /* Set up remote locale to C, otherwise dates cannot be recognized */
537 if (fish_command
538 (me, super, WAIT_REPLY,
539 "LANG=C LC_ALL=C LC_TIME=C; export LANG LC_ALL LC_TIME;\n" "echo '### 200'\n") != COMPLETE)
540 ERRNOR (E_PROTO, -1);
541
542 vfs_print_message (_("fish: Getting host info..."));
543 if (fish_info (me, super))
544 SUP->scr_env = fish_set_env (SUP->host_flags);
545
546 #if 0
547 super->name =
548 g_strconcat ("sh://", super->path_element->user, "@", super->path_element->host, "/",
549 (char *) NULL);
550 #else
551 super->name = g_strdup (PATH_SEP_STR);
552 #endif
553
554 super->root = vfs_s_new_inode (me, super, vfs_s_default_stat (me, S_IFDIR | 0755));
555 return 0;
556 }
557
558 /* --------------------------------------------------------------------------------------------- */
559
560 static int
561 fish_open_archive (struct vfs_s_super *super,
562 const vfs_path_t * vpath, const vfs_path_element_t * vpath_element)
563 {
564 (void) vpath;
565
566 super->data = g_new0 (fish_super_data_t, 1);
567 super->path_element = vfs_path_element_clone (vpath_element);
568
569 if (strncmp (vpath_element->vfs_prefix, "rsh", 3) == 0)
570 super->path_element->port = FISH_FLAG_RSH;
571
572 SUP->scr_ls =
573 fish_load_script_from_file (super->path_element->host, FISH_LS_FILE, FISH_LS_DEF_CONTENT);
574 SUP->scr_exists =
575 fish_load_script_from_file (super->path_element->host, FISH_EXISTS_FILE,
576 FISH_EXISTS_DEF_CONTENT);
577 SUP->scr_mkdir =
578 fish_load_script_from_file (super->path_element->host, FISH_MKDIR_FILE,
579 FISH_MKDIR_DEF_CONTENT);
580 SUP->scr_unlink =
581 fish_load_script_from_file (super->path_element->host, FISH_UNLINK_FILE,
582 FISH_UNLINK_DEF_CONTENT);
583 SUP->scr_chown =
584 fish_load_script_from_file (super->path_element->host, FISH_CHOWN_FILE,
585 FISH_CHOWN_DEF_CONTENT);
586 SUP->scr_chmod =
587 fish_load_script_from_file (super->path_element->host, FISH_CHMOD_FILE,
588 FISH_CHMOD_DEF_CONTENT);
589 SUP->scr_utime =
590 fish_load_script_from_file (super->path_element->host, FISH_UTIME_FILE,
591 FISH_UTIME_DEF_CONTENT);
592 SUP->scr_rmdir =
593 fish_load_script_from_file (super->path_element->host, FISH_RMDIR_FILE,
594 FISH_RMDIR_DEF_CONTENT);
595 SUP->scr_ln =
596 fish_load_script_from_file (super->path_element->host, FISH_LN_FILE, FISH_LN_DEF_CONTENT);
597 SUP->scr_mv =
598 fish_load_script_from_file (super->path_element->host, FISH_MV_FILE, FISH_MV_DEF_CONTENT);
599 SUP->scr_hardlink =
600 fish_load_script_from_file (super->path_element->host, FISH_HARDLINK_FILE,
601 FISH_HARDLINK_DEF_CONTENT);
602 SUP->scr_get =
603 fish_load_script_from_file (super->path_element->host, FISH_GET_FILE, FISH_GET_DEF_CONTENT);
604 SUP->scr_send =
605 fish_load_script_from_file (super->path_element->host, FISH_SEND_FILE,
606 FISH_SEND_DEF_CONTENT);
607 SUP->scr_append =
608 fish_load_script_from_file (super->path_element->host, FISH_APPEND_FILE,
609 FISH_APPEND_DEF_CONTENT);
610 SUP->scr_info =
611 fish_load_script_from_file (super->path_element->host, FISH_INFO_FILE,
612 FISH_INFO_DEF_CONTENT);
613
614 return fish_open_archive_int (vpath_element->class, super);
615 }
616
617 /* --------------------------------------------------------------------------------------------- */
618
619 static int
620 fish_archive_same (const vfs_path_element_t * vpath_element, struct vfs_s_super *super,
621 const vfs_path_t * vpath, void *cookie)
622 {
623 vfs_path_element_t *path_element;
624 int result;
625
626 (void) vpath;
627 (void) cookie;
628
629 path_element = vfs_path_element_clone (vpath_element);
630
631 if (path_element->user == NULL)
632 path_element->user = vfs_get_local_username ();
633
634 result = ((strcmp (path_element->host, super->path_element->host) == 0)
635 && (strcmp (path_element->user, super->path_element->user) == 0)
636 && (path_element->port == super->path_element->port)) ? 1 : 0;
637
638 vfs_path_element_free (path_element);
639
640 return result;
641 }
642
643 /* --------------------------------------------------------------------------------------------- */
644
645 static int
646 fish_dir_load (struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
647 {
648 struct vfs_s_super *super = dir->super;
649 char buffer[8192];
650 struct vfs_s_entry *ent = NULL;
651 FILE *logfile;
652 char *quoted_path;
653 int reply_code;
654 gchar *shell_commands;
655
656 /*
657 * Simple FISH debug interface :]
658 */
659 #if 0
660 if (!(MEDATA->logfile))
661 {
662 MEDATA->logfile = fopen ("/tmp/mc-FISH.sh", "w");
663 }
664 #endif
665 logfile = MEDATA->logfile;
666
667 vfs_print_message (_("fish: Reading directory %s..."), remote_path);
668
669 gettimeofday (&dir->timestamp, NULL);
670 dir->timestamp.tv_sec += fish_directory_timeout;
671 quoted_path = strutils_shell_escape (remote_path);
672 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_ls, (char *) NULL);
673 fish_command (me, super, NONE, shell_commands, quoted_path);
674 g_free (shell_commands);
675 g_free (quoted_path);
676 ent = vfs_s_generate_entry (me, NULL, dir, 0);
677 while (TRUE)
678 {
679 int res = vfs_s_get_line_interruptible (me, buffer, sizeof (buffer), SUP->sockr);
680 if ((!res) || (res == EINTR))
681 {
682 vfs_s_free_entry (me, ent);
683 me->verrno = ECONNRESET;
684 goto error;
685 }
686 if (logfile)
687 {
688 fputs (buffer, logfile);
689 fputs ("\n", logfile);
690 fflush (logfile);
691 }
692 if (!strncmp (buffer, "### ", 4))
693 break;
694 if ((!buffer[0]))
695 {
696 if (ent->name)
697 {
698 vfs_s_insert_entry (me, dir, ent);
699 ent = vfs_s_generate_entry (me, NULL, dir, 0);
700 }
701 continue;
702 }
703
704 #define ST ent->ino->st
705
706 switch (buffer[0])
707 {
708 case ':':
709 {
710 char *temp;
711 char *data_start = buffer + 1;
712 char *filename = data_start;
713 char *filename_bound;
714
715 filename_bound = filename + strlen (filename);
716
717 if (!strcmp (data_start, "\".\"") || !strcmp (data_start, "\"..\""))
718 break; /* We'll do "." and ".." ourselves */
719
720 if (S_ISLNK (ST.st_mode))
721 {
722 char *linkname;
723 char *linkname_bound;
724 /* we expect: "escaped-name" -> "escaped-name"
725 // -> cannot occur in filenames,
726 // because it will be escaped to -\> */
727
728
729 linkname_bound = filename_bound;
730
731 if (*filename == '"')
732 ++filename;
733
734 linkname = strstr (filename, "\" -> \"");
735 if (!linkname)
736 {
737 /* broken client, or smth goes wrong */
738 linkname = filename_bound;
739 if (filename_bound > filename && *(filename_bound - 1) == '"')
740 --filename_bound; /* skip trailing " */
741 }
742 else
743 {
744 filename_bound = linkname;
745 linkname += 6; /* strlen ("\" -> \"") */
746 if (*(linkname_bound - 1) == '"')
747 --linkname_bound; /* skip trailing " */
748 }
749
750 ent->name = g_strndup (filename, filename_bound - filename);
751 temp = ent->name;
752 ent->name = strutils_shell_unescape (ent->name);
753 g_free (temp);
754
755 ent->ino->linkname = g_strndup (linkname, linkname_bound - linkname);
756 temp = ent->ino->linkname;
757 ent->ino->linkname = strutils_shell_unescape (ent->ino->linkname);
758 g_free (temp);
759 }
760 else
761 {
762 /* we expect: "escaped-name" */
763 if (filename_bound - filename > 2)
764 {
765 /*
766 there is at least 2 "
767 and we skip them
768 */
769 if (*filename == '"')
770 ++filename;
771 if (*(filename_bound - 1) == '"')
772 --filename_bound;
773 }
774 ent->name = g_strndup (filename, filename_bound - filename);
775 temp = ent->name;
776 ent->name = strutils_shell_unescape (ent->name);
777 g_free (temp);
778 }
779 break;
780 }
781 case 'S':
782 ST.st_size = (off_t) g_ascii_strtoll (buffer + 1, NULL, 10);
783 break;
784 case 'P':
785 {
786 size_t skipped;
787 vfs_parse_filemode (buffer + 1, &skipped, &ST.st_mode);
788 break;
789 }
790 case 'R':
791 {
792 /*
793 raw filemode:
794 we expect: Roctal-filemode octal-filetype uid.gid
795 */
796 size_t skipped;
797 vfs_parse_raw_filemode (buffer + 1, &skipped, &ST.st_mode);
798 break;
799 }
800 case 'd':
801 {
802 vfs_split_text (buffer + 1);
803 if (!vfs_parse_filedate (0, &ST.st_ctime))
804 break;
805 ST.st_atime = ST.st_mtime = ST.st_ctime;
806 }
807 break;
808 case 'D':
809 {
810 struct tm tim;
811 if (sscanf (buffer + 1, "%d %d %d %d %d %d", &tim.tm_year, &tim.tm_mon,
812 &tim.tm_mday, &tim.tm_hour, &tim.tm_min, &tim.tm_sec) != 6)
813 break;
814 ST.st_atime = ST.st_mtime = ST.st_ctime = mktime (&tim);
815 }
816 break;
817 case 'E':
818 {
819 int maj, min;
820 if (sscanf (buffer + 1, "%d,%d", &maj, &min) != 2)
821 break;
822 #ifdef HAVE_STRUCT_STAT_ST_RDEV
823 ST.st_rdev = makedev (maj, min);
824 #endif
825 }
826 }
827 }
828
829 vfs_s_free_entry (me, ent);
830 reply_code = fish_decode_reply (buffer + 4, 0);
831 if (reply_code == COMPLETE)
832 {
833 vfs_print_message (_("%s: done."), me->name);
834 return 0;
835 }
836
837 me->verrno = reply_code == ERROR ? EACCES : E_REMOTE;
838
839 error:
840 vfs_print_message (_("%s: failure"), me->name);
841 return -1;
842 }
843
844 /* --------------------------------------------------------------------------------------------- */
845
846 static int
847 fish_file_store (struct vfs_class *me, vfs_file_handler_t * fh, char *name, char *localname)
848 {
849 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
850 gchar *shell_commands = NULL;
851 struct vfs_s_super *super = FH_SUPER;
852 int code;
853 off_t total;
854 char buffer[BUF_8K];
855 struct stat s;
856 int h;
857 char *quoted_name;
858
859 h = open (localname, O_RDONLY);
860 if (h == -1)
861 ERRNOR (EIO, -1);
862 if (fstat (h, &s) < 0)
863 {
864 close (h);
865 ERRNOR (EIO, -1);
866 }
867
868 /* First, try this as stor:
869 *
870 * ( head -c number ) | ( cat > file; cat >/dev/null )
871 *
872 * If `head' is not present on the remote system, `dd' will be used.
873 * Unfortunately, we cannot trust most non-GNU `head' implementations
874 * even if `-c' options is supported. Therefore, we separate GNU head
875 * (and other modern heads?) using `-q' and `-' . This causes another
876 * implementations to fail (because of "incorrect options").
877 *
878 * Fallback is:
879 *
880 * rest=<number>
881 * while [ $rest -gt 0 ]
882 * do
883 * cnt=`expr \( $rest + 255 \) / 256`
884 * n=`dd bs=256 count=$cnt | tee -a <target_file> | wc -c`
885 * rest=`expr $rest - $n`
886 * done
887 *
888 * `dd' was not designed for full filling of input buffers,
889 * and does not report exact number of bytes (not blocks).
890 * Therefore a more complex shell script is needed.
891 *
892 * On some systems non-GNU head writes "Usage:" error report to stdout
893 * instead of stderr. It makes impossible the use of "head || dd"
894 * algorithm for file appending case, therefore just "dd" is used for it.
895 */
896
897 quoted_name = strutils_shell_escape (name);
898 vfs_print_message (_("fish: store %s: sending command..."), quoted_name);
899
900 /* FIXME: File size is limited to ULONG_MAX */
901 if (fish->append)
902 {
903 shell_commands =
904 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX ";\n",
905 SUP->scr_append, (char *) NULL);
906
907 code = fish_command (me, super, WAIT_REPLY, shell_commands, quoted_name,
908 (uintmax_t) s.st_size);
909 g_free (shell_commands);
910 }
911 else
912 {
913 shell_commands =
914 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILESIZE=%" PRIuMAX ";\n",
915 SUP->scr_send, (char *) NULL);
916 code = fish_command (me, super, WAIT_REPLY, shell_commands, quoted_name,
917 (uintmax_t) s.st_size);
918 g_free (shell_commands);
919 }
920 if (code != PRELIM)
921 {
922 close (h);
923 ERRNOR (E_REMOTE, -1);
924 }
925
926 total = 0;
927
928 while (TRUE)
929 {
930 ssize_t n, t;
931
932 while ((n = read (h, buffer, sizeof (buffer))) < 0)
933 {
934 if ((errno == EINTR) && tty_got_interrupt ())
935 continue;
936 vfs_print_message (_("fish: Local read failed, sending zeros"));
937 close (h);
938 h = open ("/dev/zero", O_RDONLY);
939 }
940
941 if (n == 0)
942 break;
943
944 t = write (SUP->sockw, buffer, n);
945 if (t != n)
946 {
947 if (t == -1)
948 me->verrno = errno;
949 else
950 me->verrno = EIO;
951 goto error_return;
952 }
953 tty_disable_interrupt_key ();
954 total += n;
955 vfs_print_message ("%s: %" PRIuMAX "/%" PRIuMAX, _("fish: storing file"),
956 (uintmax_t) total, (uintmax_t) s.st_size);
957 }
958 close (h);
959 g_free (quoted_name);
960
961 if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
962 ERRNOR (E_REMOTE, -1);
963 return 0;
964
965 error_return:
966 close (h);
967 fish_get_reply (me, SUP->sockr, NULL, 0);
968 g_free (quoted_name);
969 return -1;
970 }
971
972 /* --------------------------------------------------------------------------------------------- */
973
974 static int
975 fish_linear_start (struct vfs_class *me, vfs_file_handler_t * fh, off_t offset)
976 {
977 fish_fh_data_t *fish;
978 gchar *shell_commands = NULL;
979 struct vfs_s_super *super = FH_SUPER;
980 char *name;
981 char *quoted_name;
982
983 if (fh->data == NULL)
984 fh->data = g_new0 (fish_fh_data_t, 1);
985
986 fish = (fish_fh_data_t *) fh->data;
987
988 name = vfs_s_fullpath (me, fh->ino);
989 if (name == NULL)
990 return 0;
991 quoted_name = strutils_shell_escape (name);
992 g_free (name);
993 fish->append = FALSE;
994
995 /*
996 * Check whether the remote file is readable by using `dd' to copy
997 * a single byte from the remote file to /dev/null. If `dd' completes
998 * with exit status of 0 use `cat' to send the file contents to the
999 * standard output (i.e. over the network).
1000 */
1001
1002 shell_commands =
1003 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_START_OFFSET=%" PRIuMAX ";\n",
1004 SUP->scr_get, (char *) NULL);
1005 offset = fish_command (me, super, WANT_STRING, shell_commands, quoted_name, (uintmax_t) offset);
1006 g_free (shell_commands);
1007 g_free (quoted_name);
1008 if (offset != PRELIM)
1009 ERRNOR (E_REMOTE, 0);
1010 fh->linear = LS_LINEAR_OPEN;
1011 fish->got = 0;
1012 errno = 0;
1013 #if SIZEOF_OFF_T == SIZEOF_LONG
1014 fish->total = (off_t) strtol (reply_str, NULL, 10);
1015 #else
1016 fish->total = (off_t) g_ascii_strtoll (reply_str, NULL, 10);
1017 #endif
1018 if (errno != 0)
1019 ERRNOR (E_REMOTE, 0);
1020 return 1;
1021 }
1022
1023 /* --------------------------------------------------------------------------------------------- */
1024
1025 static void
1026 fish_linear_abort (struct vfs_class *me, vfs_file_handler_t * fh)
1027 {
1028 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1029 struct vfs_s_super *super = FH_SUPER;
1030 char buffer[BUF_8K];
1031 ssize_t n;
1032
1033 vfs_print_message (_("Aborting transfer..."));
1034
1035 do
1036 {
1037 n = MIN ((off_t) sizeof (buffer), (fish->total - fish->got));
1038 if (n != 0)
1039 {
1040 n = read (SUP->sockr, buffer, n);
1041 if (n < 0)
1042 return;
1043 fish->got += n;
1044 }
1045 }
1046 while (n != 0);
1047
1048 if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
1049 vfs_print_message (_("Error reported after abort."));
1050 else
1051 vfs_print_message (_("Aborted transfer would be successful."));
1052 }
1053
1054 /* --------------------------------------------------------------------------------------------- */
1055
1056 static ssize_t
1057 fish_linear_read (struct vfs_class *me, vfs_file_handler_t * fh, void *buf, size_t len)
1058 {
1059 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1060 struct vfs_s_super *super = FH_SUPER;
1061 ssize_t n = 0;
1062
1063 len = MIN ((size_t) (fish->total - fish->got), len);
1064 tty_disable_interrupt_key ();
1065 while (len != 0 && ((n = read (SUP->sockr, buf, len)) < 0))
1066 {
1067 if ((errno == EINTR) && !tty_got_interrupt ())
1068 continue;
1069 break;
1070 }
1071 tty_enable_interrupt_key ();
1072
1073 if (n > 0)
1074 fish->got += n;
1075 else if (n < 0)
1076 fish_linear_abort (me, fh);
1077 else if (fish_get_reply (me, SUP->sockr, NULL, 0) != COMPLETE)
1078 ERRNOR (E_REMOTE, -1);
1079 ERRNOR (errno, n);
1080 }
1081
1082 /* --------------------------------------------------------------------------------------------- */
1083
1084 static void
1085 fish_linear_close (struct vfs_class *me, vfs_file_handler_t * fh)
1086 {
1087 fish_fh_data_t *fish = (fish_fh_data_t *) fh->data;
1088
1089 if (fish->total != fish->got)
1090 fish_linear_abort (me, fh);
1091 }
1092
1093 /* --------------------------------------------------------------------------------------------- */
1094
1095 static int
1096 fish_ctl (void *fh, int ctlop, void *arg)
1097 {
1098 (void) arg;
1099 (void) fh;
1100 (void) ctlop;
1101 return 0;
1102 #if 0
1103 switch (ctlop)
1104 {
1105 case VFS_CTL_IS_NOTREADY:
1106 {
1107 int v;
1108
1109 if (!FH->linear)
1110 vfs_die ("You may not do this");
1111 if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
1112 return 0;
1113
1114 v = vfs_s_select_on_two (FH_SUPER->u.fish.sockr, 0);
1115 if (((v < 0) && (errno == EINTR)) || v == 0)
1116 return 1;
1117 return 0;
1118 }
1119 default:
1120 return 0;
1121 }
1122 #endif
1123 }
1124
1125 /* --------------------------------------------------------------------------------------------- */
1126
1127 static int
1128 fish_send_command (struct vfs_class *me, struct vfs_s_super *super, const char *cmd, int flags)
1129 {
1130 int r;
1131
1132 r = fish_command (me, super, WAIT_REPLY, "%s", cmd);
1133 vfs_stamp_create (&vfs_fish_ops, super);
1134 if (r != COMPLETE)
1135 ERRNOR (E_REMOTE, -1);
1136 if (flags & OPT_FLUSH)
1137 vfs_s_invalidate (me, super);
1138 return 0;
1139 }
1140
1141 /* --------------------------------------------------------------------------------------------- */
1142
1143 static int
1144 fish_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1145 {
1146 gchar *shell_commands = NULL;
1147 char buf[BUF_LARGE];
1148 const char *crpath1, *crpath2;
1149 char *rpath1, *rpath2;
1150 struct vfs_s_super *super, *super2;
1151 const vfs_path_element_t *path_element;
1152
1153 path_element = vfs_path_get_by_index (vpath1, -1);
1154
1155 crpath1 = vfs_s_get_path (vpath1, &super, 0);
1156 if (crpath1 == NULL)
1157 return -1;
1158
1159 crpath2 = vfs_s_get_path (vpath2, &super2, 0);
1160 if (crpath2 == NULL)
1161 return -1;
1162
1163 rpath1 = strutils_shell_escape (crpath1);
1164 rpath2 = strutils_shell_escape (crpath2);
1165 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1166 SUP->scr_mv, (char *) NULL);
1167 g_snprintf (buf, sizeof (buf), shell_commands, rpath1, rpath2);
1168 g_free (shell_commands);
1169 g_free (rpath1);
1170 g_free (rpath2);
1171 return fish_send_command (path_element->class, super2, buf, OPT_FLUSH);
1172 }
1173
1174 /* --------------------------------------------------------------------------------------------- */
1175
1176 static int
1177 fish_link (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1178 {
1179 gchar *shell_commands = NULL;
1180 char buf[BUF_LARGE];
1181 const char *crpath1, *crpath2;
1182 char *rpath1, *rpath2;
1183 struct vfs_s_super *super, *super2;
1184 const vfs_path_element_t *path_element;
1185
1186 path_element = vfs_path_get_by_index (vpath1, -1);
1187
1188 crpath1 = vfs_s_get_path (vpath1, &super, 0);
1189 if (crpath1 == NULL)
1190 return -1;
1191
1192 crpath2 = vfs_s_get_path (vpath2, &super2, 0);
1193 if (crpath2 == NULL)
1194 return -1;
1195
1196 rpath1 = strutils_shell_escape (crpath1);
1197 rpath2 = strutils_shell_escape (crpath2);
1198 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1199 SUP->scr_hardlink, (char *) NULL);
1200 g_snprintf (buf, sizeof (buf), shell_commands, rpath1, rpath2);
1201 g_free (shell_commands);
1202 g_free (rpath1);
1203 g_free (rpath2);
1204 return fish_send_command (path_element->class, super2, buf, OPT_FLUSH);
1205 }
1206
1207
1208 /* --------------------------------------------------------------------------------------------- */
1209
1210 static int
1211 fish_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1212 {
1213 char *qsetto;
1214 gchar *shell_commands = NULL;
1215 char buf[BUF_LARGE];
1216 const char *crpath;
1217 char *rpath;
1218 struct vfs_s_super *super;
1219 const vfs_path_element_t *path_element;
1220
1221 path_element = vfs_path_get_by_index (vpath2, -1);
1222
1223 crpath = vfs_s_get_path (vpath2, &super, 0);
1224 if (crpath == NULL)
1225 return -1;
1226
1227 rpath = strutils_shell_escape (crpath);
1228 qsetto = strutils_shell_escape (vfs_path_get_by_index (vpath1, -1)->path);
1229
1230 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILEFROM=%s FISH_FILETO=%s;\n",
1231 SUP->scr_ln, (char *) NULL);
1232 g_snprintf (buf, sizeof (buf), shell_commands, qsetto, rpath);
1233 g_free (shell_commands);
1234 g_free (qsetto);
1235 g_free (rpath);
1236 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1237 }
1238
1239 /* --------------------------------------------------------------------------------------------- */
1240
1241 static int
1242 fish_chmod (const vfs_path_t * vpath, mode_t mode)
1243 {
1244 gchar *shell_commands = NULL;
1245 char buf[BUF_LARGE];
1246 const char *crpath;
1247 char *rpath;
1248 struct vfs_s_super *super;
1249 const vfs_path_element_t *path_element;
1250
1251 path_element = vfs_path_get_by_index (vpath, -1);
1252
1253 crpath = vfs_s_get_path (vpath, &super, 0);
1254 if (crpath == NULL)
1255 return -1;
1256 rpath = strutils_shell_escape (crpath);
1257
1258 shell_commands = g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILEMODE=%4.4o;\n",
1259 SUP->scr_chmod, (char *) NULL);
1260 g_snprintf (buf, sizeof (buf), shell_commands, rpath, (int) (mode & 07777));
1261 g_free (shell_commands);
1262 g_free (rpath);
1263 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1264 }
1265
1266 /* --------------------------------------------------------------------------------------------- */
1267
1268 static int
1269 fish_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
1270 {
1271 char *sowner, *sgroup;
1272 struct passwd *pw;
1273 struct group *gr;
1274
1275 pw = getpwuid (owner);
1276 if (pw == NULL)
1277 return 0;
1278
1279 gr = getgrgid (group);
1280 if (gr == NULL)
1281 return 0;
1282
1283 sowner = pw->pw_name;
1284 sgroup = gr->gr_name;
1285
1286 {
1287 gchar *shell_commands = NULL;
1288 char buf[BUF_LARGE];
1289 const char *crpath;
1290 char *rpath;
1291 struct vfs_s_super *super;
1292 const vfs_path_element_t *path_element;
1293
1294 path_element = vfs_path_get_by_index (vpath, -1);
1295
1296 crpath = vfs_s_get_path (vpath, &super, 0);
1297 if (crpath == NULL)
1298 return -1;
1299 rpath = strutils_shell_escape (crpath);
1300
1301 shell_commands = g_strconcat (SUP->scr_env,
1302 "FISH_FILENAME=%s FISH_FILEOWNER=%s FISH_FILEGROUP=%s;\n",
1303 SUP->scr_chown, (char *) NULL);
1304 g_snprintf (buf, sizeof (buf), shell_commands, rpath, sowner, sgroup);
1305 g_free (shell_commands);
1306 fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1307 /* FIXME: what should we report if chgrp succeeds but chown fails? */
1308 /* fish_send_command(me, super, buf, OPT_FLUSH); */
1309 g_free (rpath);
1310 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1311 }
1312 }
1313
1314 /* --------------------------------------------------------------------------------------------- */
1315
1316 static int
1317 fish_utime (const vfs_path_t * vpath, struct utimbuf *times)
1318 {
1319 gchar *shell_commands = NULL;
1320 char utcmtime[16], utcatime[16];
1321 struct tm *gmt;
1322
1323 char buf[BUF_LARGE];
1324 const char *crpath;
1325 char *rpath;
1326 struct vfs_s_super *super;
1327 const vfs_path_element_t *path_element;
1328
1329 path_element = vfs_path_get_by_index (vpath, -1);
1330
1331 crpath = vfs_s_get_path (vpath, &super, 0);
1332 if (crpath == NULL)
1333 return -1;
1334 rpath = strutils_shell_escape (crpath);
1335
1336 gmt = gmtime (&times->modtime);
1337 g_snprintf (utcmtime, sizeof (utcmtime), "%04d%02d%02d%02d%02d.%02d",
1338 gmt->tm_year + 1900, gmt->tm_mon + 1, gmt->tm_mday,
1339 gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
1340
1341 gmt = gmtime (&times->actime);
1342 g_snprintf (utcatime, sizeof (utcatime), "%04d%02d%02d%02d%02d.%02d",
1343 gmt->tm_year + 1900, gmt->tm_mon + 1, gmt->tm_mday,
1344 gmt->tm_hour, gmt->tm_min, gmt->tm_sec);
1345
1346 shell_commands =
1347 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s FISH_FILEATIME=%ld FISH_FILEMTIME=%ld ",
1348 "FISH_TOUCHATIME=%s FISH_TOUCHMTIME=%s;\n", SUP->scr_utime, (char *) NULL);
1349 g_snprintf (buf, sizeof (buf), shell_commands, rpath, (long) times->actime,
1350 (long) times->modtime, utcatime, utcmtime);
1351 g_free (shell_commands);
1352 g_free (rpath);
1353 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1354 }
1355
1356 /* --------------------------------------------------------------------------------------------- */
1357
1358 static int
1359 fish_unlink (const vfs_path_t * vpath)
1360 {
1361 gchar *shell_commands = NULL;
1362
1363 char buf[BUF_LARGE];
1364 const char *crpath;
1365 char *rpath;
1366 struct vfs_s_super *super;
1367 const vfs_path_element_t *path_element;
1368
1369 path_element = vfs_path_get_by_index (vpath, -1);
1370
1371 crpath = vfs_s_get_path (vpath, &super, 0);
1372 if (crpath == NULL)
1373 return -1;
1374 rpath = strutils_shell_escape (crpath);
1375
1376 shell_commands =
1377 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_unlink, (char *) NULL);
1378 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1379 g_free (shell_commands);
1380 g_free (rpath);
1381 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1382 }
1383
1384 /* --------------------------------------------------------------------------------------------- */
1385
1386 static int
1387 fish_exists (const vfs_path_t * vpath)
1388 {
1389 gchar *shell_commands = NULL;
1390
1391 char buf[BUF_LARGE];
1392 const char *crpath;
1393 char *rpath;
1394 struct vfs_s_super *super;
1395 const vfs_path_element_t *path_element;
1396
1397 path_element = vfs_path_get_by_index (vpath, -1);
1398
1399 crpath = vfs_s_get_path (vpath, &super, 0);
1400 if (crpath == NULL)
1401 return -1;
1402 rpath = strutils_shell_escape (crpath);
1403
1404 shell_commands =
1405 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_exists, (char *) NULL);
1406 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1407 g_free (shell_commands);
1408 g_free (rpath);
1409
1410 return (fish_send_command (path_element->class, super, buf, OPT_FLUSH) == 0) ? 1 : 0;
1411 }
1412
1413 /* --------------------------------------------------------------------------------------------- */
1414
1415 static int
1416 fish_mkdir (const vfs_path_t * vpath, mode_t mode)
1417 {
1418 gchar *shell_commands = NULL;
1419 int ret_code;
1420 char buf[BUF_LARGE];
1421 const char *crpath;
1422 char *rpath;
1423 struct vfs_s_super *super;
1424 const vfs_path_element_t *path_element;
1425
1426 (void) mode;
1427
1428 path_element = vfs_path_get_by_index (vpath, -1);
1429
1430 crpath = vfs_s_get_path (vpath, &super, 0);
1431 if (crpath == NULL)
1432 return -1;
1433 rpath = strutils_shell_escape (crpath);
1434
1435 shell_commands =
1436 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_mkdir, (char *) NULL);
1437 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1438 g_free (shell_commands);
1439
1440 g_free (rpath);
1441 ret_code = fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1442
1443 if (ret_code != 0)
1444 return ret_code;
1445
1446 if (!fish_exists (vpath))
1447 {
1448 path_element->class->verrno = EACCES;
1449 return -1;
1450 }
1451 return 0;
1452 }
1453
1454 /* --------------------------------------------------------------------------------------------- */
1455
1456 static int
1457 fish_rmdir (const vfs_path_t * vpath)
1458 {
1459 gchar *shell_commands = NULL;
1460 char buf[BUF_LARGE];
1461 const char *crpath;
1462 char *rpath;
1463 struct vfs_s_super *super;
1464 const vfs_path_element_t *path_element;
1465
1466 path_element = vfs_path_get_by_index (vpath, -1);
1467
1468 crpath = vfs_s_get_path (vpath, &super, 0);
1469 if (crpath == NULL)
1470 return -1;
1471 rpath = strutils_shell_escape (crpath);
1472
1473 shell_commands =
1474 g_strconcat (SUP->scr_env, "FISH_FILENAME=%s;\n", SUP->scr_rmdir, (char *) NULL);
1475 g_snprintf (buf, sizeof (buf), shell_commands, rpath);
1476 g_free (shell_commands);
1477 g_free (rpath);
1478 return fish_send_command (path_element->class, super, buf, OPT_FLUSH);
1479 }
1480
1481 /* --------------------------------------------------------------------------------------------- */
1482
1483 static void
1484 fish_fh_free_data (vfs_file_handler_t * fh)
1485 {
1486 if (fh != NULL)
1487 {
1488 g_free (fh->data);
1489 fh->data = NULL;
1490 }
1491 }
1492
1493 /* --------------------------------------------------------------------------------------------- */
1494
1495 static int
1496 fish_fh_open (struct vfs_class *me, vfs_file_handler_t * fh, int flags, mode_t mode)
1497 {
1498 fish_fh_data_t *fish;
1499
1500 (void) mode;
1501
1502 fh->data = g_new0 (fish_fh_data_t, 1);
1503 fish = (fish_fh_data_t *) fh->data;
1504
1505 /* File will be written only, so no need to retrieve it */
1506 if (((flags & O_WRONLY) == O_WRONLY) && ((flags & (O_RDONLY | O_RDWR)) == 0))
1507 {
1508 /* user pressed the button [ Append ] in the "Copy" dialog */
1509 if ((flags & O_APPEND) != 0)
1510 fish->append = TRUE;
1511
1512 if (!fh->ino->localname)
1513 {
1514 vfs_path_t *vpath;
1515 int tmp_handle;
1516
1517 tmp_handle = vfs_mkstemps (&vpath, me->name, fh->ino->ent->name);
1518 if (tmp_handle == -1)
1519 {
1520 vfs_path_free (vpath);
1521 goto fail;
1522 }
1523 fh->ino->localname = vfs_path_to_str (vpath);
1524 vfs_path_free (vpath);
1525 close (tmp_handle);
1526 }
1527 return 0;
1528 }
1529 if (!fh->ino->localname && vfs_s_retrieve_file (me, fh->ino) == -1)
1530 goto fail;
1531 if (!fh->ino->localname)
1532 vfs_die ("retrieve_file failed to fill in localname");
1533 return 0;
1534
1535 fail:
1536 fish_fh_free_data (fh);
1537 return -1;
1538 }
1539
1540 /* --------------------------------------------------------------------------------------------- */
1541
1542 static void
1543 fish_fill_names (struct vfs_class *me, fill_names_f func)
1544 {
1545 GList *iter;
1546
1547 for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
1548 {
1549 const struct vfs_s_super *super = (const struct vfs_s_super *) iter->data;
1550
1551 char *name;
1552 char gbuf[10];
1553 const char *flags = "";
1554
1555 switch (super->path_element->port)
1556 {
1557 case FISH_FLAG_RSH:
1558 flags = ":r";
1559 break;
1560 case FISH_FLAG_COMPRESSED:
1561 flags = ":C";
1562 break;
1563 default:
1564 if (super->path_element->port > FISH_FLAG_RSH)
1565 {
1566 g_snprintf (gbuf, sizeof (gbuf), ":%d", super->path_element->port);
1567 flags = gbuf;
1568 }
1569 break;
1570 }
1571
1572 name =
1573 g_strconcat (vfs_fish_ops.prefix, VFS_PATH_URL_DELIMITER,
1574 super->path_element->user, "@", super->path_element->host, flags, "/",
1575 super->path_element->path, (char *) NULL);
1576 func (name);
1577 g_free (name);
1578 }
1579 }
1580
1581 /* --------------------------------------------------------------------------------------------- */
1582
1583 static void *
1584 fish_open (const vfs_path_t * vpath, int flags, mode_t mode)
1585 {
1586 /*
1587 sorry, i've places hack here
1588 cause fish don't able to open files with O_EXCL flag
1589 */
1590 flags &= ~O_EXCL;
1591 return vfs_s_open (vpath, flags, mode);
1592 }
1593
1594 /* --------------------------------------------------------------------------------------------- */
1595 /*** public functions ****************************************************************************/
1596 /* --------------------------------------------------------------------------------------------- */
1597
1598 void
1599 init_fish (void)
1600 {
1601 static struct vfs_s_subclass fish_subclass;
1602
1603 tcp_init ();
1604
1605 fish_subclass.flags = VFS_S_REMOTE | VFS_S_USETMP;
1606 fish_subclass.archive_same = fish_archive_same;
1607 fish_subclass.open_archive = fish_open_archive;
1608 fish_subclass.free_archive = fish_free_archive;
1609 fish_subclass.fh_open = fish_fh_open;
1610 fish_subclass.fh_free_data = fish_fh_free_data;
1611 fish_subclass.dir_load = fish_dir_load;
1612 fish_subclass.file_store = fish_file_store;
1613 fish_subclass.linear_start = fish_linear_start;
1614 fish_subclass.linear_read = fish_linear_read;
1615 fish_subclass.linear_close = fish_linear_close;
1616
1617 vfs_s_init_class (&vfs_fish_ops, &fish_subclass);
1618 vfs_fish_ops.name = "fish";
1619 vfs_fish_ops.prefix = "sh";
1620 vfs_fish_ops.fill_names = fish_fill_names;
1621 vfs_fish_ops.chmod = fish_chmod;
1622 vfs_fish_ops.chown = fish_chown;
1623 vfs_fish_ops.utime = fish_utime;
1624 vfs_fish_ops.open = fish_open;
1625 vfs_fish_ops.symlink = fish_symlink;
1626 vfs_fish_ops.link = fish_link;
1627 vfs_fish_ops.unlink = fish_unlink;
1628 vfs_fish_ops.rename = fish_rename;
1629 vfs_fish_ops.mkdir = fish_mkdir;
1630 vfs_fish_ops.rmdir = fish_rmdir;
1631 vfs_fish_ops.ctl = fish_ctl;
1632 vfs_register_class (&vfs_fish_ops);
1633 }
1634
1635 /* --------------------------------------------------------------------------------------------- */
Midnight Commander