vfs/fish.c

   1 /* Virtual File System: FISH implementation for transfering files over
   2    shell connections.
   3
   4    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   5    2007 Free Software Foundation, Inc.
   6
   7    Written by: 1998 Pavel Machek
   8    Spaces fix: 2000 Michal Svec
   9
  10    Derived from ftpfs.c.
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Library General Public License
  14    as published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU Library General Public License for more details.
  21
  22    You should have received a copy of the GNU Library General Public
  23    License along with this program; if not, write to the Free Software
  24    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  25
  26 /**
  27  * \file
  28  * \brief Source: Virtual File System: FISH implementation for transfering files over
  29  * shell connections
  30  * \author Pavel Machek
  31  * \author Michal Svec
  32  * \date 1998, 2000
  33  *
  34  * Derived from ftpfs.c
  35  * Read README.fish for protocol specification.
  36  *
  37  * Syntax of path is: \verbatim /#sh:user@host[:Cr]/path \endverbatim
  38  *      where C means you want compressed connection,
  39  *      and r means you want to use rsh
  40  *
  41  * Namespace: fish_vfs_ops exported.
  42  */
  43
  44 /* Define this if your ssh can take -I option */
  45
  46 #include <config.h>
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <pwd.h>
  50 #include <grp.h>
  51 #include <sys/time.h>           /* gettimeofday() */
  52 #include <stdlib.h>
  53 #include <string.h>
  54
  55 #include "../src/global.h"
  56
  57 #include "../src/tty/tty.h"     /* enable/disable interrupt key */
  58
  59 #include "../src/wtools.h"      /* message() */
  60 #include "../src/main.h"        /* print_vfs_message */
  61 #include "../src/util.h"
  62 #include "../src/strescape.h"
  63 #include "../src/unixcompat.h"
  64 #include "../src/fs.h"
  65 #include "utilvfs.h"
  66 #include "xdirentry.h"
  67 #include "vfs.h"
  68 #include "vfs-impl.h"
  69 #include "gc.h"         /* vfs_stamp_create */
  70 #include "tcputil.h"
  71 #include "fish.h"
  72
  73 int fish_directory_timeout = 900;
  74
  75 #define DO_RESOLVE_SYMLINK 1
  76 #define DO_OPEN            2
  77 #define DO_FREE_RESOURCE   4
  78
  79 #define FISH_FLAG_COMPRESSED 1
  80 #define FISH_FLAG_RSH        2
  81
  82 #define OPT_FLUSH        1
  83 #define OPT_IGNORE_ERROR 2
  84
  85 /*
  86  * Reply codes.
  87  */
  88 #define PRELIM          1       /* positive preliminary */
  89 #define COMPLETE        2       /* positive completion */
  90 #define CONTINUE        3       /* positive intermediate */
  91 #define TRANSIENT       4       /* transient negative completion */
  92 #define ERROR           5       /* permanent negative completion */
  93
  94 /* command wait_flag: */
  95 #define NONE        0x00
  96 #define WAIT_REPLY  0x01
  97 #define WANT_STRING 0x02
  98 static char reply_str [80];
  99
 100 static struct vfs_class vfs_fish_ops;
 101
 102 static int
 103  fish_command (struct vfs_class *me, struct vfs_s_super *super,
 104                int wait_reply, const char *fmt, ...)
 105     __attribute__ ((format (__printf__, 4, 5)));
 106
 107 static int fish_decode_reply (char *s, int was_garbage)
 108 {
 109     int code;
 110     if (!sscanf(s, "%d", &code)) {
 111         code = 500;
 112         return 5;
 113     }
 114     if (code<100) return was_garbage ? ERROR : (!code ? COMPLETE : PRELIM);
 115     return code / 100;
 116 }
 117
 118 /* Returns a reply code, check /usr/include/arpa/ftp.h for possible values */
 119 static int fish_get_reply (struct vfs_class *me, int sock, char *string_buf, int string_len)
 120 {
 121     char answer[1024];
 122     int was_garbage = 0;
 123
 124     for (;;) {
 125         if (!vfs_s_get_line(me, sock, answer, sizeof(answer), '\n')) {
 126             if (string_buf)
 127                 *string_buf = 0;
 128             return 4;
 129         }
 130
 131         if (strncmp(answer, "### ", 4)) {
 132             was_garbage = 1;
 133             if (string_buf)
 134                 g_strlcpy(string_buf, answer, string_len);
 135         } else return fish_decode_reply(answer+4, was_garbage);
 136     }
 137 }
 138
 139 #define SUP super->u.fish
 140
 141 static int
 142 fish_command (struct vfs_class *me, struct vfs_s_super *super,
 143               int wait_reply, const char *fmt, ...)
 144 {
 145     va_list ap;
 146     char *str;
 147     int status;
 148     FILE *logfile = MEDATA->logfile;
 149
 150     va_start (ap, fmt);
 151
 152     str = g_strdup_vprintf (fmt, ap);
 153     va_end (ap);
 154
 155     if (logfile) {
 156         fwrite (str, strlen (str), 1, logfile);
 157         fflush (logfile);
 158     }
 159
 160     tty_enable_interrupt_key ();
 161
 162     status = write (SUP.sockw, str, strlen (str));
 163     g_free (str);
 164
 165     tty_disable_interrupt_key ();
 166     if (status < 0)
 167         return TRANSIENT;
 168
 169     if (wait_reply)
 170         return fish_get_reply (me, SUP.sockr,
 171                                (wait_reply & WANT_STRING) ? reply_str :
 172                                NULL, sizeof (reply_str) - 1);
 173     return COMPLETE;
 174 }
 175
 176 static void
 177 fish_free_archive (struct vfs_class *me, struct vfs_s_super *super)
 178 {
 179     if ((SUP.sockw != -1) || (SUP.sockr != -1)) {
 180         print_vfs_message (_("fish: Disconnecting from %s"),
 181                            super->name ? super->name : "???");
 182         fish_command (me, super, NONE, "#BYE\nexit\n");
 183         close (SUP.sockw);
 184         close (SUP.sockr);
 185         SUP.sockw = SUP.sockr = -1;
 186     }
 187     g_free (SUP.host);
 188     g_free (SUP.user);
 189     g_free (SUP.cwdir);
 190     g_free (SUP.password);
 191 }
 192
 193 static void
 194 fish_pipeopen(struct vfs_s_super *super, const char *path, const char *argv[])
 195 {
 196     int fileset1[2], fileset2[2];
 197     int res;
 198
 199     if ((pipe(fileset1)<0) || (pipe(fileset2)<0))
 200         vfs_die("Cannot pipe(): %m.");
 201
 202     if ((res = fork())) {
 203         if (res<0) vfs_die("Cannot fork(): %m.");
 204         /* We are the parent */
 205         close(fileset1[0]);
 206         SUP.sockw = fileset1[1];
 207         close(fileset2[1]);
 208         SUP.sockr = fileset2[0];
 209     } else {
 210         close(0);
 211         dup(fileset1[0]);
 212         close(fileset1[0]); close(fileset1[1]);
 213         close(1); close(2);
 214         dup(fileset2[1]);
 215         /* stderr to /dev/null */
 216         open ("/dev/null", O_WRONLY);
 217         close(fileset2[0]); close(fileset2[1]);
 218         execvp(path, const_cast(char **, argv));
 219         _exit(3);
 220     }
 221 }
 222
 223 /* The returned directory should always contain a trailing slash */
 224 static char *fish_getcwd(struct vfs_class *me, struct vfs_s_super *super)
 225 {
 226     if (fish_command (me, super, WANT_STRING, "#PWD\npwd; echo '### 200'\n") == COMPLETE)
 227         return  g_strconcat (reply_str, "/", (char *) NULL);
 228     ERRNOR (EIO, NULL);
 229 }
 230
 231 static int
 232 fish_open_archive_int (struct vfs_class *me, struct vfs_s_super *super)
 233 {
 234     {
 235         char gbuf[10];
 236         const char *argv[10];   /* All of 10 is used now */
 237         const char *xsh = (SUP.flags == FISH_FLAG_RSH ? "rsh" : "ssh");
 238         int i = 0;
 239
 240         argv[i++] = xsh;
 241         if (SUP.flags == FISH_FLAG_COMPRESSED)
 242             argv[i++] = "-C";
 243
 244         if (SUP.flags > FISH_FLAG_RSH)
 245         {
 246             argv[i++] = "-p";
 247             g_snprintf (gbuf, sizeof (gbuf), "%d", SUP.flags);
 248             argv[i++] = gbuf;
 249         }
 250
 251         argv[i++] = "-l";
 252         argv[i++] = SUP.user;
 253         argv[i++] = SUP.host;
 254         argv[i++] = "echo FISH:; /bin/sh";
 255         argv[i++] = NULL;
 256
 257         fish_pipeopen (super, xsh, argv);
 258     }
 259     {
 260         char answer[2048];
 261         print_vfs_message (_("fish: Waiting for initial line..."));
 262         if (!vfs_s_get_line (me, SUP.sockr, answer, sizeof (answer), ':'))
 263             ERRNOR (E_PROTO, -1);
 264         print_vfs_message ("%s", answer);
 265         if (strstr (answer, "assword")) {
 266
 267             /* Currently, this does not work. ssh reads passwords from
 268                /dev/tty, not from stdin :-(. */
 269
 270             message (D_ERROR, MSG_ERROR,
 271                      _
 272                      ("Sorry, we cannot do password authenticated connections for now."));
 273             ERRNOR (EPERM, -1);
 274             if (!SUP.password) {
 275                 char *p, *op;
 276                 p = g_strconcat (_(" fish: Password required for "),
 277                                  SUP.user, " ", (char *) NULL);
 278                 op = vfs_get_password (p);
 279                 g_free (p);
 280                 if (op == NULL)
 281                     ERRNOR (EPERM, -1);
 282                 SUP.password = op;
 283             }
 284             print_vfs_message (_("fish: Sending password..."));
 285             write (SUP.sockw, SUP.password, strlen (SUP.password));
 286             write (SUP.sockw, "\n", 1);
 287         }
 288     }
 289
 290     print_vfs_message (_("fish: Sending initial line..."));
 291     /*
 292      * Run `start_fish_server'. If it doesn't exist - no problem,
 293      * we'll talk directly to the shell.
 294      */
 295     if (fish_command
 296         (me, super, WAIT_REPLY,
 297          "#FISH\necho; start_fish_server 2>&1; echo '### 200'\n") !=
 298         COMPLETE)
 299         ERRNOR (E_PROTO, -1);
 300
 301     print_vfs_message (_("fish: Handshaking version..."));
 302     if (fish_command
 303         (me, super, WAIT_REPLY,
 304          "#VER 0.0.0\necho '### 000'\n") != COMPLETE)
 305         ERRNOR (E_PROTO, -1);
 306
 307     /* Set up remote locale to C, otherwise dates cannot be recognized */
 308     if (fish_command
 309         (me, super, WAIT_REPLY,
 310          "LANG=C; LC_ALL=C; LC_TIME=C\n"
 311          "export LANG; export LC_ALL; export LC_TIME\n" "echo '### 200'\n")
 312         != COMPLETE)
 313         ERRNOR (E_PROTO, -1);
 314
 315     print_vfs_message (_("fish: Setting up current directory..."));
 316     SUP.cwdir = fish_getcwd (me, super);
 317     print_vfs_message (_("fish: Connected, home %s."), SUP.cwdir);
 318 #if 0
 319     super->name =
 320         g_strconcat ("/#sh:", SUP.user, "@", SUP.host, "/", (char *) NULL);
 321 #endif
 322     super->name = g_strdup (PATH_SEP_STR);
 323
 324     super->root =
 325         vfs_s_new_inode (me, super,
 326                          vfs_s_default_stat (me, S_IFDIR | 0755));
 327     return 0;
 328 }
 329
 330 static int
 331 fish_open_archive (struct vfs_class *me, struct vfs_s_super *super,
 332                    const char *archive_name, char *op)
 333 {
 334     char *host, *user, *password, *p;
 335     int flags;
 336
 337     (void) archive_name;
 338
 339     p = vfs_split_url (strchr (op, ':') + 1, &host, &user, &flags,
 340                        &password, 0, URL_NOSLASH);
 341
 342     g_free (p);
 343
 344     SUP.host = host;
 345     SUP.user = user;
 346     SUP.flags = flags;
 347     if (!strncmp (op, "rsh:", 4))
 348         SUP.flags = FISH_FLAG_RSH;
 349     SUP.cwdir = NULL;
 350     if (password)
 351         SUP.password = password;
 352     return fish_open_archive_int (me, super);
 353 }
 354
 355 static int
 356 fish_archive_same (struct vfs_class *me, struct vfs_s_super *super,
 357                    const char *archive_name, char *op, void *cookie)
 358 {
 359     char *host, *user;
 360     int flags;
 361
 362     (void) me;
 363     (void) archive_name;
 364     (void) cookie;
 365
 366     op = vfs_split_url (strchr (op, ':') + 1, &host, &user, &flags, 0, 0,
 367                         URL_NOSLASH);
 368
 369     g_free (op);
 370
 371     flags = ((strcmp (host, SUP.host) == 0)
 372              && (strcmp (user, SUP.user) == 0) && (flags == SUP.flags));
 373     g_free (host);
 374     g_free (user);
 375
 376     return flags;
 377 }
 378
 379 static int
 380 fish_dir_load(struct vfs_class *me, struct vfs_s_inode *dir, char *remote_path)
 381 {
 382     struct vfs_s_super *super = dir->super;
 383     char buffer[8192];
 384     struct vfs_s_entry *ent = NULL;
 385     FILE *logfile;
 386     char *quoted_path;
 387     int reply_code;
 388     gchar *shell_commands;
 389
 390 #if 0
 391     /*
 392      * Simple FISH debug interface :]
 393      */
 394     if (!(MEDATA->logfile))
 395     {
 396         MEDATA->logfile = fopen("/tmp/mc-FISH.sh", "w");
 397     }
 398 #endif /* 0 */
 399
 400     logfile = MEDATA->logfile;
 401
 402     print_vfs_message(_("fish: Reading directory %s..."), remote_path);
 403
 404     gettimeofday(&dir->timestamp, NULL);
 405     dir->timestamp.tv_sec += fish_directory_timeout;
 406     quoted_path = strutils_shell_escape (remote_path);
 407     shell_commands = g_strconcat(
 408                 "#LIST /%s\n"
 409                 "if `perl -v > /dev/null 2>&1` ; then\n"
 410                   "perl -e '\n"
 411                    "use strict;\n"
 412                    "use POSIX;\n"
 413                    "use Fcntl;\n"
 414                    "use POSIX \":fcntl_h\"; #S_ISLNK was here until 5.6\n"
 415                    "import Fcntl \":mode\" unless defined &S_ISLNK; #and is now here\n"
 416                    "my $dirname = $ARGV[0];\n"
 417                    "if (opendir ( DIR, $dirname )) {\n"
 418                    "while( (my $filename = readdir(DIR))){\n"
 419                    "my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,$blksize,$blocks) = lstat(\"$dirname/$filename\");\n"
 420                    "my $mloctime= strftime(\"%%m-%%d-%%Y %%H:%%M\", localtime $mtime);\n"
 421         ,
 422                    "my $strutils_shell_escape_regex= s/([;<>\\*\\|`&\\$!#\\(\\)\\[\\]\\{\\}:'\\''\"\\ \\\\])/\\\\$1/g;\n"
 423                    "my $e_filename = $filename;\n"
 424                    "$e_filename =~ $strutils_shell_escape_regex;\n"
 425                    "if (S_ISLNK($mode) ) {\n"
 426                    "my $linkname = readlink (\"$dirname/$filename\");\n"
 427                    "$linkname =~ $strutils_shell_escape_regex;\n"
 428                    "\n"
 429                           "printf(\"R%%o %%o $uid.$gid\\n"
 430                                     "S$size\\n"
 431                                     "d$mloctime\\n"
 432                                     ":\\\"$e_filename\\\" -> \\\"$linkname\\\"\\n"
 433                                     "\\n\", S_IMODE($mode), S_IFMT($mode));\n"
 434                    "} else {\n"
 435                           "printf(\"R%%o %%o $uid.$gid\\n"
 436                                     "S$size\\n"
 437                                     "d$mloctime\\n"
 438                                     ":\\\"$e_filename\\\"\\n"
 439                                     "\\n\", S_IMODE($mode), S_IFMT($mode));\n"
 440                    "}}\n"
 441         ,
 442                    "printf(\"### 200\\n\");\n"
 443                    "closedir(DIR);\n"
 444                    "} else {\n"
 445                     "printf(\"### 500\\n\");\n"
 446                    "}\n"
 447                    "exit 0\n"
 448                    "' /%s ||\n" /* ARGV[0] - path to browse */
 449                    "    echo '### 500'\n" /* do not hang if perl is to eval it */
 450                 "elif `ls -1 /%s >/dev/null 2>&1` ; then\n"
 451                   "if `ls -Q /%s >/dev/null 2>&1`; then\n"
 452                           "LSOPT=\"-Qlan\";\n"
 453                           "ADD=0;\n"
 454                   "else\n"
 455                           "LSOPT=\"-lan\";\n"
 456                           "ADD=1;\n"
 457                   "fi\n"
 458                   "ls $LSOPT /%s 2>/dev/null | grep '^[^cbt]' | (\n"
 459                           "while read p l u g s m d y n n2 n3; do\n"
 460                                   "if test \"$m\" = \"0\" ; then \n"
 461                                           "s=$d; m=$y; d=$n y=$n2; n=$n3\n"
 462                                   "else\n"
 463                                           "n=$n\" \"$n2\" \"$n3\n"
 464                                   "fi\n"
 465                                   "if [ $ADD  = 0 ]; then\n"
 466                                           "echo \"P$p $u.$g\nS$s\nd$m $d $y\n:$n\n\"\n"
 467                                   "elif `sed --version >/dev/null 2>&1` ; then\n"
 468                                           "file=`echo $n | sed -e 's#^\\(.*\\) -> \\(.*\\)#\\1\" -> \"\\2#'`\n"
 469         ,
 470                                           "echo \"P$p $u $g\nS$s\nd$m $d $y\n:\"$file\"\n\"\n"
 471                                   "else\n"
 472                                           "echo \"P$p $u $g\nS$s\nd$m $d $y\n:\"$n\"\n\"\n"
 473                                   "fi\n"
 474                           "done )\n"
 475                   "ls $LSOPT /%s 2>/dev/null | grep '^[cb]' | (\n"
 476                           "while read p l u g a i m d y n n2 n3; do\n"
 477                                   "if test \"$a\" = \"0\" ; then \n"
 478                                           "a=$m; i=$d; m=$y; d=$n y=$n2; n=$n3\n"
 479                                   "else\n"
 480                                           "n=$n\" \"$n2\" \"$n3\n"
 481                                   "fi\n"
 482                                   "if [ $ADD = 0 ]; then\n"
 483                                           "echo \"P$p $u.$g\nE$a$i\nd$m $d $y\n:$n\n\"\n"
 484                                   "elif `sed --version >/dev/null 2>&1` ; then\n"
 485                                           "file=`echo $n | sed -e 's#^\\(.*\\) -> \\(.*\\)#\\1\" -> \"\\2#'`\n"
 486                                           "echo \"P$p $u $g\nS$s\nd$m $d $y\n:\"$file\"\n\"\n"
 487                                   "else\n"
 488                                           "echo \"P$p $u $g\nS$s\nd$m $d $y\n:\"$n\"\n\"\n"
 489                                   "fi\n"
 490                           "done)\n"
 491                   "echo '### 200'\n"
 492         "else\n"
 493                   "echo '### 500'\n"
 494         "fi\n"
 495         , (char *) NULL
 496     );
 497
 498     fish_command (me, super, NONE, shell_commands,
 499             quoted_path, quoted_path, quoted_path, quoted_path, quoted_path, quoted_path);
 500
 501     g_free(shell_commands);
 502     g_free (quoted_path);
 503     ent = vfs_s_generate_entry(me, NULL, dir, 0);
 504     while (1) {
 505         int res = vfs_s_get_line_interruptible (me, buffer, sizeof (buffer), SUP.sockr);
 506         if ((!res) || (res == EINTR)) {
 507             vfs_s_free_entry(me, ent);
 508             me->verrno = ECONNRESET;
 509             goto error;
 510         }
 511         if (logfile) {
 512             fputs (buffer, logfile);
 513             fputs ("\n", logfile);
 514             fflush (logfile);
 515         }
 516         if (!strncmp(buffer, "### ", 4))
 517             break;
 518         if ((!buffer[0])) {
 519             if (ent->name) {
 520                 vfs_s_insert_entry(me, dir, ent);
 521                 ent = vfs_s_generate_entry(me, NULL, dir, 0);
 522             }
 523             continue;
 524         }
 525
 526 #define ST ent->ino->st
 527
 528         switch(buffer[0]) {
 529         case ':': {
 530             char *temp;
 531             char *data_start = buffer+1;
 532             char *filename = data_start;
 533             char *linkname = data_start;
 534             char *filename_bound = filename + strlen(filename);
 535             char *linkname_bound = filename_bound;
 536             if (!strcmp(data_start, "\".\"") || !strcmp(data_start, "\"..\""))
 537                         break;  /* We'll do "." and ".." ourselves */
 538
 539                 if (S_ISLNK(ST.st_mode)) {
 540                         /* we expect: "escaped-name" -> "escaped-name"
 541                         //     -> cannot occur in filenames,
 542                         //     because it will be escaped to -\> */
 543
 544                         if (*filename == '"')
 545                                 ++filename;
 546
 547                         linkname = strstr(filename, "\" -> \"");
 548                         if (!linkname)
 549                         {
 550                                 /* broken client, or smth goes wrong */
 551                                 linkname = filename_bound;
 552                                 if (filename_bound > filename
 553                                     && *(filename_bound - 1) == '"')
 554                                         --filename_bound; /* skip trailing " */
 555                         }
 556                         else
 557                         {
 558                                 filename_bound = linkname;
 559                                 linkname += 6; /* strlen ("\" -> \"") */
 560                                 if (*(linkname_bound - 1) == '"')
 561                                         --linkname_bound; /* skip trailing " */
 562                         }
 563
 564                         ent->name = str_dup_range(filename, filename_bound);
 565                         temp = ent->name;
 566                         ent->name = strutils_shell_unescape(ent->name);
 567                         g_free(temp);
 568
 569                         ent->ino->linkname = str_dup_range(linkname, linkname_bound);
 570                         temp = ent->ino->linkname;
 571                         ent->ino->linkname = strutils_shell_unescape(ent->ino->linkname);
 572                         g_free(temp);
 573                 } else {
 574                         /* we expect: "escaped-name" */
 575                         if (filename_bound - filename > 2)
 576                         {
 577                                 /*
 578                                  there is at least 2 "
 579                                  and we skip them
 580                                 */
 581                                 if (*filename == '"')
 582                                         ++filename;
 583                                 if (*(filename_bound - 1) == '"')
 584                                         --filename_bound;
 585                         }
 586                         ent->name = str_dup_range(filename, filename_bound);
 587                         temp = ent->name;
 588                         ent->name = strutils_shell_unescape(ent->name);
 589                         g_free(temp);
 590                 }
 591                 break;
 592         }
 593         case 'S':
 594 #ifdef HAVE_ATOLL
 595             ST.st_size = (off_t) atoll (buffer+1);
 596 #else
 597             ST.st_size = (off_t) atof (buffer+1);
 598 #endif
 599             break;
 600         case 'P': {
 601             size_t skipped;
 602             vfs_parse_filemode (buffer + 1, &skipped, &ST.st_mode);
 603             break;
 604         }
 605         case 'R': {
 606             /*
 607                raw filemode:
 608                we expect: Roctal-filemode octal-filetype uid.gid
 609             */
 610             size_t skipped;
 611             vfs_parse_raw_filemode (buffer + 1, &skipped, &ST.st_mode);
 612             break;
 613         }
 614         case 'd': {
 615                       vfs_split_text(buffer+1);
 616                       if (!vfs_parse_filedate(0, &ST.st_ctime))
 617                           break;
 618                       ST.st_atime = ST.st_mtime = ST.st_ctime;
 619                   }
 620                   break;
 621         case 'D': {
 622                       struct tm tim;
 623                       if (sscanf(buffer+1, "%d %d %d %d %d %d", &tim.tm_year, &tim.tm_mon,
 624                                  &tim.tm_mday, &tim.tm_hour, &tim.tm_min, &tim.tm_sec) != 6)
 625                           break;
 626                       ST.st_atime = ST.st_mtime = ST.st_ctime = mktime(&tim);
 627                   }
 628                   break;
 629         case 'E': {
 630                       int maj, min;
 631                       if (sscanf(buffer+1, "%d,%d", &maj, &min) != 2)
 632                           break;
 633 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 634                       ST.st_rdev = makedev (maj, min);
 635 #endif
 636                   }
 637         }
 638     }
 639
 640     vfs_s_free_entry (me, ent);
 641     reply_code = fish_decode_reply(buffer + 4, 0);
 642     if (reply_code == COMPLETE) {
 643         g_free (SUP.cwdir);
 644         SUP.cwdir = g_strdup (remote_path);
 645         print_vfs_message (_("%s: done."), me->name);
 646         return 0;
 647     } else if (reply_code == ERROR) {
 648         me->verrno = EACCES;
 649     } else {
 650         me->verrno = E_REMOTE;
 651     }
 652
 653 error:
 654     print_vfs_message (_("%s: failure"), me->name);
 655     return -1;
 656 }
 657
 658 static int
 659 fish_file_store(struct vfs_class *me, struct vfs_s_fh *fh, char *name, char *localname)
 660 {
 661     struct vfs_s_super *super = FH_SUPER;
 662     int n, total;
 663     char buffer[8192];
 664     struct stat s;
 665     int was_error = 0;
 666     int h;
 667     char *quoted_name;
 668
 669     h = open (localname, O_RDONLY);
 670
 671     if (h == -1)
 672         ERRNOR (EIO, -1);
 673     if (fstat(h, &s)<0) {
 674         close (h);
 675         ERRNOR (EIO, -1);
 676     }
 677
 678     /* First, try this as stor:
 679      *
 680      *     ( head -c number ) | ( cat > file; cat >/dev/null )
 681      *
 682      *  If `head' is not present on the remote system, `dd' will be used.
 683      * Unfortunately, we cannot trust most non-GNU `head' implementations
 684      * even if `-c' options is supported. Therefore, we separate GNU head
 685      * (and other modern heads?) using `-q' and `-' . This causes another
 686      * implementations to fail (because of "incorrect options").
 687      *
 688      *  Fallback is:
 689      *
 690      *     rest=<number>
 691      *     while [ $rest -gt 0 ]
 692      *     do
 693      *        cnt=`expr \( $rest + 255 \) / 256`
 694      *        n=`dd bs=256 count=$cnt | tee -a <target_file> | wc -c`
 695      *        rest=`expr $rest - $n`
 696      *     done
 697      *
 698      *  `dd' was not designed for full filling of input buffers,
 699      *  and does not report exact number of bytes (not blocks).
 700      *  Therefore a more complex shell script is needed.
 701      *
 702      *   On some systems non-GNU head writes "Usage:" error report to stdout
 703      *  instead of stderr. It makes impossible the use of "head || dd"
 704      *  algorithm for file appending case, therefore just "dd" is used for it.
 705      */
 706
 707     quoted_name = strutils_shell_escape(name);
 708     print_vfs_message(_("fish: store %s: sending command..."), quoted_name );
 709
 710     /* FIXME: File size is limited to ULONG_MAX */
 711     if (!fh->u.fish.append)
 712         n = fish_command (me, super, WAIT_REPLY,
 713                  "#STOR %lu /%s\n"
 714                  "echo '### 001'\n"
 715                  "file=/%s\n"
 716                  "res=`exec 3>&1\n"
 717                  "(\n"
 718                    "head -c %lu -q - || echo DD >&3\n"
 719                  ") 2>/dev/null | (\n"
 720                    "cat > $file\n"
 721                    "cat > /dev/null\n"
 722                  ")`; [ \"$res\" = DD ] && {\n"
 723                         "> \"$file\"\n"
 724                         "rest=%lu\n"
 725                         "while [ $rest -gt 0 ]\n"
 726                         "do\n"
 727                         "    cnt=`expr \\( $rest + 255 \\) / 256`\n"
 728                         "    n=`dd bs=256 count=$cnt | tee -a \"$file\" | wc -c`\n"
 729                         "    rest=`expr $rest - $n`\n"
 730                         "done\n"
 731                  "}; echo '### 200'\n",
 732                  (unsigned long) s.st_size, quoted_name,
 733                  quoted_name, (unsigned long) s.st_size,
 734                  (unsigned long) s.st_size);
 735     else
 736         n = fish_command (me, super, WAIT_REPLY,
 737                  "#STOR %lu /%s\n"
 738                  "echo '### 001'\n"
 739                  "{\n"
 740                         "file=/%s\n"
 741                         "rest=%lu\n"
 742                         "while [ $rest -gt 0 ]\n"
 743                         "do\n"
 744                         "    cnt=`expr \\( $rest + 255 \\) / 256`\n"
 745                         "    n=`dd bs=256 count=$cnt | tee -a $file | wc -c`\n"
 746                         "    rest=`expr $rest - $n`\n"
 747                         "done\n"
 748                  "}; echo '### 200'\n",
 749                  (unsigned long) s.st_size, quoted_name,
 750                  quoted_name, (unsigned long) s.st_size);
 751
 752     if (n != PRELIM) {
 753         close (h);
 754         ERRNOR(E_REMOTE, -1);
 755     }
 756     total = 0;
 757
 758     while (1) {
 759         int t;
 760         while ((n = read(h, buffer, sizeof(buffer))) < 0) {
 761             if ((errno == EINTR) && tty_got_interrupt ())
 762                 continue;
 763             print_vfs_message(_("fish: Local read failed, sending zeros") );
 764             close(h);
 765             h = open( "/dev/zero", O_RDONLY );
 766         }
 767         if (n == 0)
 768             break;
 769         if ((t = write (SUP.sockw, buffer, n)) != n) {
 770             if (t == -1) {
 771                 me->verrno = errno;
 772             } else {
 773                 me->verrno = EIO;
 774             }
 775             goto error_return;
 776         }
 777         tty_disable_interrupt_key ();
 778         total += n;
 779         print_vfs_message(_("fish: storing %s %d (%lu)"),
 780                           was_error ? _("zeros") : _("file"), total,
 781                           (unsigned long) s.st_size);
 782     }
 783     close(h);
 784     g_free(quoted_name);
 785     if ((fish_get_reply (me, SUP.sockr, NULL, 0) != COMPLETE) || was_error)
 786         ERRNOR (E_REMOTE, -1);
 787     return 0;
 788 error_return:
 789     close(h);
 790     fish_get_reply(me, SUP.sockr, NULL, 0);
 791     g_free(quoted_name);
 792     return -1;
 793 }
 794
 795 static int
 796 fish_linear_start (struct vfs_class *me, struct vfs_s_fh *fh, off_t offset)
 797 {
 798     char *name;
 799     char *quoted_name;
 800     if (offset)
 801         ERRNOR (E_NOTSUPP, 0);
 802     name = vfs_s_fullpath (me, fh->ino);
 803     if (!name)
 804         return 0;
 805     quoted_name = strutils_shell_escape(name);
 806     fh->u.fish.append = 0;
 807
 808     /*
 809      * Check whether the remote file is readable by using `dd' to copy
 810      * a single byte from the remote file to /dev/null. If `dd' completes
 811      * with exit status of 0 use `cat' to send the file contents to the
 812      * standard output (i.e. over the network).
 813      */
 814     offset = fish_command (me, FH_SUPER, WANT_STRING,
 815                 "#RETR /%s\n"
 816                 "if dd if=/%s of=/dev/null bs=1 count=1 2>/dev/null ;\n"
 817                 "then\n"
 818                 "ls -ln /%s 2>/dev/null | (\n"
 819                   "read p l u g s r\n"
 820                   "echo $s\n"
 821                 ")\n"
 822                 "echo '### 100'\n"
 823                 "cat /%s\n"
 824                 "echo '### 200'\n"
 825                 "else\n"
 826                 "echo '### 500'\n"
 827                 "fi\n",
 828                 quoted_name, quoted_name, quoted_name, quoted_name );
 829     g_free (quoted_name);
 830     if (offset != PRELIM) ERRNOR (E_REMOTE, 0);
 831     fh->linear = LS_LINEAR_OPEN;
 832     fh->u.fish.got = 0;
 833     errno = 0;
 834 #if SIZEOF_OFF_T == SIZEOF_LONG
 835     fh->u.fish.total = strtol (reply_str, NULL, 10);
 836 #else
 837     fh->u.fish.total = strtoll (reply_str, NULL, 10);
 838 #endif
 839     if (errno != 0)
 840         ERRNOR (E_REMOTE, 0);
 841     return 1;
 842 }
 843
 844 static void
 845 fish_linear_abort (struct vfs_class *me, struct vfs_s_fh *fh)
 846 {
 847     struct vfs_s_super *super = FH_SUPER;
 848     char buffer[8192];
 849     int n;
 850
 851     print_vfs_message( _("Aborting transfer...") );
 852     do {
 853         n = MIN(8192, fh->u.fish.total - fh->u.fish.got);
 854         if (n) {
 855             if ((n = read(SUP.sockr, buffer, n)) < 0)
 856                 return;
 857             fh->u.fish.got += n;
 858         }
 859     } while (n);
 860
 861     if (fish_get_reply (me, SUP.sockr, NULL, 0) != COMPLETE)
 862         print_vfs_message( _("Error reported after abort.") );
 863     else
 864         print_vfs_message( _("Aborted transfer would be successful.") );
 865 }
 866
 867 static int
 868 fish_linear_read (struct vfs_class *me, struct vfs_s_fh *fh, void *buf, int len)
 869 {
 870     struct vfs_s_super *super = FH_SUPER;
 871     int n = 0;
 872     len = MIN( fh->u.fish.total - fh->u.fish.got, len );
 873     tty_disable_interrupt_key ();
 874     while (len && ((n = read (SUP.sockr, buf, len))<0)) {
 875         if ((errno == EINTR) && !tty_got_interrupt ())
 876             continue;
 877         break;
 878     }
 879     tty_enable_interrupt_key();
 880
 881     if (n>0) fh->u.fish.got += n;
 882     if (n<0) fish_linear_abort(me, fh);
 883     if ((!n) && ((fish_get_reply (me, SUP.sockr, NULL, 0) != COMPLETE)))
 884         ERRNOR (E_REMOTE, -1);
 885     ERRNOR (errno, n);
 886 }
 887
 888 static void
 889 fish_linear_close (struct vfs_class *me, struct vfs_s_fh *fh)
 890 {
 891     if (fh->u.fish.total != fh->u.fish.got)
 892         fish_linear_abort(me, fh);
 893 }
 894
 895 static int
 896 fish_ctl (void *fh, int ctlop, void *arg)
 897 {
 898     (void) arg;
 899     (void) fh;
 900     (void) ctlop;
 901     return 0;
 902 #if 0
 903     switch (ctlop) {
 904         case VFS_CTL_IS_NOTREADY:
 905             {
 906                 int v;
 907
 908                 if (!FH->linear)
 909                     vfs_die ("You may not do this");
 910                 if (FH->linear == LS_LINEAR_CLOSED || FH->linear == LS_LINEAR_PREOPEN)
 911                     return 0;
 912
 913                 v = vfs_s_select_on_two (FH_SUPER->u.fish.sockr, 0);
 914                 if (((v < 0) && (errno == EINTR)) || v == 0)
 915                     return 1;
 916                 return 0;
 917             }
 918         default:
 919             return 0;
 920     }
 921 #endif
 922 }
 923
 924 static int
 925 fish_send_command(struct vfs_class *me, struct vfs_s_super *super, const char *cmd, int flags)
 926 {
 927     int r;
 928
 929     r = fish_command (me, super, WAIT_REPLY, "%s", cmd);
 930     vfs_stamp_create (&vfs_fish_ops, super);
 931     if (r != COMPLETE) ERRNOR (E_REMOTE, -1);
 932     if (flags & OPT_FLUSH)
 933         vfs_s_invalidate(me, super);
 934     return 0;
 935 }
 936
 937 #define PREFIX \
 938     char buf[BUF_LARGE]; \
 939     const char *crpath; \
 940     char *rpath, *mpath = g_strdup (path); \
 941     struct vfs_s_super *super; \
 942     if (!(crpath = vfs_s_get_path_mangle (me, mpath, &super, 0))) { \
 943         g_free (mpath); \
 944         return -1; \
 945     } \
 946     rpath = strutils_shell_escape(crpath); \
 947     g_free (mpath);
 948
 949 #define POSTFIX(flags) \
 950     g_free (rpath); \
 951     return fish_send_command(me, super, buf, flags);
 952
 953 static int
 954 fish_chmod (struct vfs_class *me, const char *path, int mode)
 955 {
 956     PREFIX
 957     g_snprintf(buf, sizeof(buf), "#CHMOD %4.4o /%s\n"
 958                                  "if chmod %4.4o /%s 2>/dev/null; then\n"
 959                                     "echo '### 000'\n"
 960                                  "else\n"
 961                                     "echo '### 500'\n"
 962                                  "fi\n",
 963             mode & 07777, rpath,
 964             mode & 07777, rpath);
 965     POSTFIX(OPT_FLUSH);
 966 }
 967
 968 #define FISH_OP(name, string) \
 969 static int fish_##name (struct vfs_class *me, const char *path1, const char *path2) \
 970 { \
 971     char buf[BUF_LARGE]; \
 972     const char *crpath1, *crpath2; \
 973     char *rpath1, *rpath2, *mpath1, *mpath2; \
 974     struct vfs_s_super *super1, *super2; \
 975     if (!(crpath1 = vfs_s_get_path_mangle (me, mpath1 = g_strdup(path1), &super1, 0))) { \
 976         g_free (mpath1); \
 977         return -1; \
 978     } \
 979     if (!(crpath2 = vfs_s_get_path_mangle (me, mpath2 = g_strdup(path2), &super2, 0))) { \
 980         g_free (mpath1); \
 981         g_free (mpath2); \
 982         return -1; \
 983     } \
 984     rpath1 = strutils_shell_escape (crpath1); \
 985     g_free (mpath1); \
 986     rpath2 = strutils_shell_escape (crpath2); \
 987     g_free (mpath2); \
 988     g_snprintf(buf, sizeof(buf), string "\n", rpath1, rpath2, rpath1, rpath2); \
 989     g_free (rpath1); \
 990     g_free (rpath2); \
 991     return fish_send_command(me, super2, buf, OPT_FLUSH); \
 992 }
 993
 994 FISH_OP(rename, "#RENAME /%s /%s\n"
 995                 "if mv /%s /%s 2>/dev/null; then\n"
 996                     "echo '### 000'\n"
 997                 "else\n"
 998                     "echo '### 500'\n"
 999                 "fi\n")
1000 FISH_OP(link,   "#LINK /%s /%s\n"
1001                 "if ln /%s /%s 2>/dev/null; then\n"
1002                     "echo '### 000'\n"
1003                 "else\n"
1004                     "echo '### 500'\n"
1005                 "fi\n")
1006
1007 static int fish_symlink (struct vfs_class *me, const char *setto, const char *path)
1008 {
1009     char *qsetto;
1010     PREFIX
1011     qsetto = strutils_shell_escape (setto);
1012     g_snprintf(buf, sizeof(buf),
1013             "#SYMLINK %s /%s\n"
1014             "if ln -s %s /%s 2>/dev/null; then\n"
1015                 "echo '### 000'\n"
1016             "else\n"
1017                 "echo '### 500'\n"
1018             "fi\n",
1019             qsetto, rpath, qsetto, rpath);
1020     g_free (qsetto);
1021     POSTFIX(OPT_FLUSH);
1022 }
1023
1024 static int
1025 fish_chown (struct vfs_class *me, const char *path, int owner, int group)
1026 {
1027     char *sowner, *sgroup;
1028     struct passwd *pw;
1029     struct group *gr;
1030
1031     if ((pw = getpwuid (owner)) == NULL)
1032         return 0;
1033
1034     if ((gr = getgrgid (group)) == NULL)
1035         return 0;
1036
1037     sowner = pw->pw_name;
1038     sgroup = gr->gr_name;
1039     {
1040         PREFIX
1041         g_snprintf (buf, sizeof(buf),
1042             "#CHOWN %s:%s /%s\n"
1043             "if chown %s:%s /%s 2>/dev/null; then\n"
1044                 "echo '### 000'\n"
1045             "else\n"
1046                 "echo '### 500'\n"
1047             "fi\n",
1048             sowner, sgroup, rpath,
1049             sowner, sgroup, rpath);
1050         fish_send_command (me, super, buf, OPT_FLUSH);
1051         /* FIXME: what should we report if chgrp succeeds but chown fails? */
1052         /* fish_send_command(me, super, buf, OPT_FLUSH); */
1053         POSTFIX (OPT_FLUSH)
1054     }
1055 }
1056
1057 static int fish_unlink (struct vfs_class *me, const char *path)
1058 {
1059     PREFIX
1060     g_snprintf(buf, sizeof(buf),
1061             "#DELE /%s\n"
1062             "if rm -f /%s 2>/dev/null; then\n"
1063                 "echo '### 000'\n"
1064             "else\n"
1065                 "echo '### 500'\n"
1066             "fi\n",
1067             rpath, rpath);
1068     POSTFIX(OPT_FLUSH);
1069 }
1070
1071 static int fish_exists (struct vfs_class *me, const char *path)
1072 {
1073     PREFIX
1074
1075     g_snprintf(buf, sizeof(buf),
1076             "#ISEXISTS /%s\n"
1077             "ls -l /%s >/dev/null 2>/dev/null\n"
1078             "echo '### '$?\n",
1079             rpath, rpath);
1080
1081     g_free (rpath);
1082
1083     if ( fish_send_command(me, super, buf, OPT_FLUSH) == 0 )
1084         return 1;
1085
1086     return 0;
1087 }
1088
1089
1090 static int fish_mkdir (struct vfs_class *me, const char *path, mode_t mode)
1091 {
1092     int ret_code;
1093
1094     PREFIX
1095
1096     (void) mode;
1097
1098     g_snprintf(buf, sizeof(buf),
1099             "#MKD /%s\n"
1100             "if mkdir /%s 2>/dev/null; then\n"
1101                 "echo '### 000'\n"
1102             "else\n"
1103                 "echo '### 500'\n"
1104             "fi\n",
1105             rpath, rpath);
1106
1107     g_free (rpath);
1108     ret_code = fish_send_command(me, super, buf, OPT_FLUSH);
1109
1110     if ( ret_code != 0 )
1111         return ret_code;
1112
1113     if ( ! fish_exists (me, path) ){
1114         ERRNOR (EACCES, -1);
1115     }
1116     return 0;
1117 }
1118
1119 static int fish_rmdir (struct vfs_class *me, const char *path)
1120 {
1121     PREFIX
1122     g_snprintf(buf, sizeof(buf),
1123             "#RMD /%s\n"
1124             "if rmdir /%s 2>/dev/null; then\n"
1125                 "echo '### 000'\n"
1126             "else\n"
1127                 "echo '### 500'\n"
1128             "fi\n",
1129             rpath, rpath);
1130     POSTFIX(OPT_FLUSH);
1131 }
1132
1133 static int
1134 fish_fh_open (struct vfs_class *me, struct vfs_s_fh *fh, int flags,
1135               int mode)
1136 {
1137     (void) mode;
1138
1139     fh->u.fish.append = 0;
1140     /* File will be written only, so no need to retrieve it */
1141     if (((flags & O_WRONLY) == O_WRONLY) && !(flags & (O_RDONLY | O_RDWR))) {
1142         fh->u.fish.append = flags & O_APPEND;
1143         if (!fh->ino->localname) {
1144             int tmp_handle =
1145                 vfs_mkstemps (&fh->ino->localname, me->name,
1146                               fh->ino->ent->name);
1147             if (tmp_handle == -1)
1148                 return -1;
1149             close (tmp_handle);
1150         }
1151         return 0;
1152     }
1153     if (!fh->ino->localname)
1154         if (vfs_s_retrieve_file (me, fh->ino) == -1)
1155             return -1;
1156     if (!fh->ino->localname)
1157         vfs_die ("retrieve_file failed to fill in localname");
1158     return 0;
1159 }
1160
1161 static void
1162 fish_fill_names (struct vfs_class *me, fill_names_f func)
1163 {
1164     struct vfs_s_super *super = MEDATA->supers;
1165     char *name;
1166
1167     char gbuf[10];
1168
1169     while (super)
1170     {
1171         const char *flags = "";
1172         switch (SUP.flags)
1173         {
1174             case FISH_FLAG_RSH:
1175                 flags = ":r";
1176                 break;
1177             case FISH_FLAG_COMPRESSED:
1178                 flags = ":C";
1179                 break;
1180             default:
1181                 if (SUP.flags > FISH_FLAG_RSH)
1182                 {
1183                     break;
1184                     g_snprintf (gbuf, sizeof (gbuf), ":%d", SUP.flags);
1185                     flags = gbuf;
1186                 }
1187                 break;
1188         }
1189
1190         name = g_strconcat ("/#sh:", SUP.user, "@", SUP.host, flags,
1191                             "/", SUP.cwdir, (char *) NULL);
1192         (*func)(name);
1193         g_free (name);
1194         super = super->next;
1195     }
1196 }
1197
1198 static void *
1199 fish_open (struct vfs_class *me, const char *file, int flags, int mode)
1200 {
1201     /*
1202       sorry, i've places hack here
1203       cause fish don't able to open files with O_EXCL flag
1204     */
1205     flags &= ~O_EXCL;
1206     return vfs_s_open (me, file, flags, mode);
1207 }
1208
1209
1210 void
1211 init_fish (void)
1212 {
1213     static struct vfs_s_subclass fish_subclass;
1214
1215     fish_subclass.flags = VFS_S_REMOTE;
1216     fish_subclass.archive_same = fish_archive_same;
1217     fish_subclass.open_archive = fish_open_archive;
1218     fish_subclass.free_archive = fish_free_archive;
1219     fish_subclass.fh_open = fish_fh_open;
1220     fish_subclass.dir_load = fish_dir_load;
1221     fish_subclass.file_store = fish_file_store;
1222     fish_subclass.linear_start = fish_linear_start;
1223     fish_subclass.linear_read = fish_linear_read;
1224     fish_subclass.linear_close = fish_linear_close;
1225
1226     vfs_s_init_class (&vfs_fish_ops, &fish_subclass);
1227     vfs_fish_ops.name = "fish";
1228     vfs_fish_ops.prefix = "sh:";
1229     vfs_fish_ops.fill_names = fish_fill_names;
1230     vfs_fish_ops.chmod = fish_chmod;
1231     vfs_fish_ops.chown = fish_chown;
1232     vfs_fish_ops.open = fish_open;
1233     vfs_fish_ops.symlink = fish_symlink;
1234     vfs_fish_ops.link = fish_link;
1235     vfs_fish_ops.unlink = fish_unlink;
1236     vfs_fish_ops.rename = fish_rename;
1237     vfs_fish_ops.mkdir = fish_mkdir;
1238     vfs_fish_ops.rmdir = fish_rmdir;
1239     vfs_fish_ops.ctl = fish_ctl;
1240     vfs_register_class (&vfs_fish_ops);
1241 }