mc/vfs/mcfs.c

/* Virtual File System: Midnight Commander file system.
   
   Copyright (C) 1995, 1996, 1997 The Free Software Foundation

   Written by Miguel de Icaza
              Andrej Borsenkow
	      Norbert Warmuth
   
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License
   as published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* Namespace: exports mcfs_vfs_ops, tcp_invalidate_socket */

#include <config.h>

#ifdef WITH_MCFS
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pwd.h>
#include <sys/types.h>		/* POSIX-required by sys/socket.h and netdb.h */
#include <netdb.h>		/* struct hostent */
#include <sys/socket.h>		/* AF_INET */
#include <netinet/in.h>		/* struct in_addr */
#ifdef HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif

#ifdef HAVE_PMAP_SET
#include <rpc/rpc.h>
#include <rpc/pmap_prot.h>
#ifdef HAVE_RPC_PMAP_CLNT_H
#include <rpc/pmap_clnt.h>
#endif
#endif

#include "utilvfs.h"

#include "vfs.h"
#include "mcfs.h"
#include "mcfsutil.h"
#include "tcputil.h"
#include "../src/dialog.h"

#define MCFS_MAX_CONNECTIONS 32

static struct _mcfs_connection {
    char *host;
    char *user;
    char *home;
    int sock;
    int port;
    int version;
} mcfs_connections[MCFS_MAX_CONNECTIONS];


#define mcserver_port 9876

typedef struct _mcfs_connection mcfs_connection;

typedef struct {
    int handle;
    mcfs_connection *conn;
} mcfs_handle;

static int my_errno;

static char *mcfs_gethome (mcfs_connection * mc);

/* Extract the hostname and username from the path */
/* path is in the form: hostname:user/remote-dir */
static char *
mcfs_get_host_and_username (char *path, char **host, char **user,
			    int *port, char **pass)
{
    return vfs_split_url (path, host, user, port, pass, 0, 0);
}

static void
mcfs_fill_names (vfs *me, void (*func) (char *))
{
    int i;
    char *name;

    for (i = 0; i < MCFS_MAX_CONNECTIONS; i++) {
	if (mcfs_connections[i].host == 0)
	    continue;
	name = g_strconcat ("/#mc:", mcfs_connections[i].user,
			    "@", mcfs_connections[i].host, NULL);
	(*func) (name);
	g_free (name);
    }
}

/* This routine checks the server RPC version and logs the user in */
static int
mcfs_login_server (int my_socket, char *user, int port,
		   int port_autodetected, char *netrcpass, int *version)
{
    int result;
    char *pass;

    /* Send the version number */
    rpc_send (my_socket, RPC_INT, *version, RPC_END);
    if (0 == rpc_get (my_socket, RPC_INT, &result, RPC_END))
	return 0;

    if (result != MC_VERSION_OK) {
	message_1s (1, _(" MCFS "),
		    _(" The server does not support this version "));
	close (my_socket);
	return 0;
    }

    /* FIXME: figure out why last_current_dir used to be passed here */
    rpc_send (my_socket, RPC_INT, MC_LOGIN, RPC_STRING, "/",
	      RPC_STRING, user, RPC_END);

    if (0 == rpc_get (my_socket, RPC_INT, &result, RPC_END))
	return 0;

    if (result == MC_NEED_PASSWORD) {
	if (port > 1024 && port_autodetected) {
	    int v;
	    v = query_dialog (_("Warning"),
			      _
			      (" The remote server is not running on a system port \n"
			       " you need a password to log in, but the information may \n"
			       " not be safe on the remote side.  Continue? \n"),
			      3, 2, _("&Yes"), _("&No"));

	    if (v == 1) {
		close (my_socket);
		return 0;
	    }
	}
	if (netrcpass != NULL)
	    pass = g_strdup (netrcpass);
	else
	    pass = vfs_get_password (_(" MCFS Password required "));
	if (!pass) {
	    rpc_send (my_socket, RPC_INT, MC_QUIT, RPC_END);
	    close (my_socket);
	    return 0;
	}
	rpc_send (my_socket, RPC_INT, MC_PASS, RPC_STRING, pass, RPC_END);

	wipe_password (pass);

	if (0 == rpc_get (my_socket, RPC_INT, &result, RPC_END))
	    return 0;

	if (result != MC_LOGINOK) {
	    message_1s (1, _(" MCFS "), _(" Invalid password "));
	    rpc_send (my_socket, RPC_INT, MC_QUIT, RPC_END);
	    close (my_socket);
	    return 0;
	}
    }
    return my_socket;
}

static int
get_remote_port (struct sockaddr_in *sin, int *version)
{
#ifdef HAVE_PMAP_GETMAPS
    int port;
    struct pmaplist *pl;

    *version = 1;
    port = mcserver_port;
    for (pl = pmap_getmaps (sin); pl; pl = pl->pml_next)
	if (pl->pml_map.pm_prog == RPC_PROGNUM
	    && pl->pml_map.pm_prot == IPPROTO_TCP
	    && pl->pml_map.pm_vers >= *version) {
	    *version = pl->pml_map.pm_vers;
	    port = pl->pml_map.pm_port;
	}
    return port;
#else
#ifdef HAVE_PMAP_GETPORT
    int port;
    for (*version = RPC_PROGVER; *version >= 1; (*version)--)
	if (port = pmap_getport (sin, RPC_PROGNUM, *version, IPPROTO_TCP))
	    return port;
#endif				/* HAVE_PMAP_GETPORT */
#endif				/* HAVE_PMAP_GETMAPS */
    *version = 1;
    return mcserver_port;
}

/* This used to be in utilvfs.c, but as it deals with portmapper, it
   is probably useful for mcfs */
static int
open_tcp_link (char *host, int *port, int *version, char *caller)
{
    struct sockaddr_in server_address;
    unsigned long inaddr;
    struct hostent *hp;
    int my_socket;

    if (!*host)
	return 0;

    memset ((char *) &server_address, 0, sizeof (server_address));
    server_address.sin_family = AF_INET;

    /*  Try to use the dotted decimal number */
    if ((inaddr = inet_addr (host)) != -1)
	memcpy ((char *) &server_address.sin_addr, (char *) &inaddr,
		sizeof (inaddr));
    else {
	if ((hp = gethostbyname (host)) == NULL) {
	    message_2s (1, caller, _(" Cannot locate hostname: %s "),
			host);
	    return 0;
	}
	memcpy ((char *) &server_address.sin_addr, (char *) hp->h_addr,
		hp->h_length);
    }

    /* Try to contact a remote portmapper to obtain the listening port */
    if (*port == 0) {
	*port = get_remote_port (&server_address, version);
	if (*port < 1)
	    return 0;
    } else
	*version = 1;

    server_address.sin_port = htons (*port);

    if ((my_socket = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
	message_2s (1, caller, _(" Cannot create socket: %s "),
		    unix_error_string (errno));
	return 0;
    }
    if (connect (my_socket, (struct sockaddr *) &server_address,
		 sizeof (server_address)) < 0) {
	message_2s (1, caller, _(" Cannot connect to server: %s "),
		    unix_error_string (errno));
	close (my_socket);
	return 0;
    }
    return my_socket;
}

static int
mcfs_open_tcp_link (char *host, char *user,
		    int *port, char *netrcpass, int *version)
{
    int my_socket;
    int old_port = *port;

    my_socket = open_tcp_link (host, port, version, " MCfs ");
    if (my_socket <= 0)
	return 0;

    /* We got the connection to the server, verify if the server
       implements our version of the RPC mechanism and then login
       the user.
     */
    return mcfs_login_server (my_socket, user, *port, old_port == 0,
			      netrcpass, version);
}

static int mcfs_get_free_bucket_init = 1;
static mcfs_connection *
mcfs_get_free_bucket (void)
{
    int i;

    if (mcfs_get_free_bucket_init) {
	mcfs_get_free_bucket_init = 0;
	for (i = 0; i < MCFS_MAX_CONNECTIONS; i++)
	    mcfs_connections[i].host = 0;
    }
    for (i = 0; i < MCFS_MAX_CONNECTIONS; i++) {
	if (!mcfs_connections[i].host)
	    return &mcfs_connections[i];
    }
    /* This can't happend, since we have checked for max connections before */
    vfs_die ("Internal error: mcfs_get_free_bucket");
    return 0;			/* shut up, stupid gcc */
}

/* This routine keeps track of open connections */
/* Returns a connected socket to host */
static mcfs_connection *
mcfs_open_link (char *host, char *user, int *port, char *netrcpass)
{
    static int mcfs_open_connections = 0;
    int i, sock, version;
    mcfs_connection *bucket;

    /* Is the link actually open? */
    if (mcfs_get_free_bucket_init) {
	mcfs_get_free_bucket_init = 0;
	for (i = 0; i < MCFS_MAX_CONNECTIONS; i++)
	    mcfs_connections[i].host = 0;
    } else
	for (i = 0; i < MCFS_MAX_CONNECTIONS; i++) {
	    if (!mcfs_connections[i].host)
		continue;
	    if ((strcmp (host, mcfs_connections[i].host) == 0) &&
		(strcmp (user, mcfs_connections[i].user) == 0))
		return &mcfs_connections[i];
	}
    if (mcfs_open_connections == MCFS_MAX_CONNECTIONS) {
	message_1s (1, MSG_ERROR, _(" Too many open connections "));
	return 0;
    }

    if (!
	(sock =
	 mcfs_open_tcp_link (host, user, port, netrcpass, &version)))
	return 0;

    bucket = mcfs_get_free_bucket ();
    mcfs_open_connections++;
    bucket->host = g_strdup (host);
    bucket->user = g_strdup (user);
    bucket->home = 0;
    bucket->port = *port;
    bucket->sock = sock;
    bucket->version = version;

    return bucket;
}

static int
is_error (int result, int errno_num)
{
    if (!(result == -1))
	return my_errno = 0;
    else
	my_errno = errno_num;
    return 1;
}

static int
the_error (int result, int errno_num)
{
    if (result == -1)
	my_errno = errno_num;
    else
	my_errno = 0;
    return result;
}

static char *
mcfs_get_path (mcfs_connection **mc, char *path)
{
    char *user, *host, *remote_path;
    char *pass;
    int port;

    /* An absolute path name, try to determine connection socket */
    if (strncmp (path, "/#mc:", 5))
	return NULL;
    path += 5;

    /* Port = 0 means that open_tcp_link will try to contact the
     * remote portmapper to get the port number
     */
    port = 0;
    if ((remote_path =
	 mcfs_get_host_and_username (path, &host, &user, &port, &pass)))
	if (!(*mc = mcfs_open_link (host, user, &port, pass))) {
	    g_free (remote_path);
	    remote_path = NULL;
	}
    g_free (host);
    g_free (user);
    if (pass)
	wipe_password (pass);

    if (!remote_path)
	return NULL;

    /* NOTE: tildes are deprecated. See ftpfs.c */
    {
	int f = !strcmp (remote_path, "/~");
	if (f || !strncmp (remote_path, "/~/", 3)) {
	    char *s;
	    s = concat_dir_and_file (mcfs_gethome (*mc),
				     remote_path + 3 - f);
	    g_free (remote_path);
	    remote_path = s;
	}
    }
    return remote_path;
}

/* Simple function for routines returning only an integer from the server */
static int
mcfs_handle_simple_error (int sock, int return_status)
{
    int status, error;

    if (0 == rpc_get (sock, RPC_INT, &status, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    if (is_error (status, error))
	return -1;
    if (return_status)
	return status;
    return 0;
}

/* Nice wrappers */
static int
mcfs_rpc_two_paths (int command, char *s1, char *s2)
{
    mcfs_connection *mc;
    char *r1, *r2;

    if ((r1 = mcfs_get_path (&mc, s1)) == 0)
	return -1;

    if ((r2 = mcfs_get_path (&mc, s2)) == 0) {
	g_free (r1);
	return -1;
    }

    rpc_send (mc->sock,
	      RPC_INT, command, RPC_STRING, r1, RPC_STRING, r2, RPC_END);
    g_free (r1);
    g_free (r2);
    return mcfs_handle_simple_error (mc->sock, 0);
}

static int
mcfs_rpc_path (int command, char *path)
{
    mcfs_connection *mc;
    char *remote_file;

    if ((remote_file = mcfs_get_path (&mc, path)) == 0)
	return -1;

    rpc_send (mc->sock,
	      RPC_INT, command, RPC_STRING, remote_file, RPC_END);

    g_free (remote_file);
    return mcfs_handle_simple_error (mc->sock, 0);
}

static int
mcfs_rpc_path_int (int command, char *path, int data)
{
    mcfs_connection *mc;
    char *remote_file;

    if ((remote_file = mcfs_get_path (&mc, path)) == 0)
	return -1;

    rpc_send (mc->sock,
	      RPC_INT, command,
	      RPC_STRING, remote_file, RPC_INT, data, RPC_END);

    g_free (remote_file);
    return mcfs_handle_simple_error (mc->sock, 0);
}

static int
mcfs_rpc_path_int_int (int command, char *path, int n1, int n2)
{
    mcfs_connection *mc;
    char *remote_file;

    if ((remote_file = mcfs_get_path (&mc, path)) == 0)
	return -1;

    rpc_send (mc->sock,
	      RPC_INT, command,
	      RPC_STRING, remote_file, RPC_INT, n1, RPC_INT, n2, RPC_END);

    g_free (remote_file);
    return mcfs_handle_simple_error (mc->sock, 0);
}

static char *
mcfs_gethome (mcfs_connection *mc)
{
    char *buffer;

    if (mc->home)
	return g_strdup (mc->home);
    else {
	rpc_send (mc->sock, RPC_INT, MC_GETHOME, RPC_END);
	if (0 == rpc_get (mc->sock, RPC_STRING, &buffer, RPC_END))
	    return g_strdup (PATH_SEP_STR);
	mc->home = buffer;
	return g_strdup (buffer);
    }
}

/* The callbacks */
static void *
mcfs_open (vfs *me, char *file, int flags, int mode)
{
    char *remote_file;
    mcfs_connection *mc;
    int result, error_num;
    mcfs_handle *remote_handle;

    if (!(remote_file = mcfs_get_path (&mc, file)))
	return 0;

    rpc_send (mc->sock, RPC_INT, MC_OPEN, RPC_STRING, remote_file,
	      RPC_INT, flags, RPC_INT, mode, RPC_END);
    g_free (remote_file);

    if (0 ==
	rpc_get (mc->sock, RPC_INT, &result, RPC_INT, &error_num, RPC_END))
	return 0;

    if (is_error (result, error_num))
	return 0;

    remote_handle = g_new (mcfs_handle, 2);
    remote_handle->handle = result;
    remote_handle->conn = mc;

    return remote_handle;
}

static int
mcfs_read (void *data, char *buffer, int count)
{
    mcfs_handle *info = (mcfs_handle *) data;
    int result, error;
    int handle;
    mcfs_connection *mc;

    mc = info->conn;
    handle = info->handle;

    rpc_send (mc->sock, RPC_INT, MC_READ, RPC_INT, handle,
	      RPC_INT, count, RPC_END);

    if (0 ==
	rpc_get (mc->sock, RPC_INT, &result, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    if (is_error (result, error))
	return 0;

    if (0 == rpc_get (mc->sock, RPC_BLOCK, result, buffer, RPC_END))
	return the_error (-1, EIO);

    return result;
}

static int
mcfs_write (void *data, char *buf, int nbyte)
{
    mcfs_handle *info = (mcfs_handle *) data;
    mcfs_connection *mc;
    int handle;

    mc = info->conn;
    handle = info->handle;

    rpc_send (mc->sock,
	      RPC_INT, MC_WRITE,
	      RPC_INT, handle,
	      RPC_INT, nbyte, RPC_BLOCK, nbyte, buf, RPC_END);

    return mcfs_handle_simple_error (mc->sock, 1);
}

static int
mcfs_close (void *data)
{
    mcfs_handle *info = (mcfs_handle *) data;
    mcfs_connection *mc;
    int handle, result, error;

    if (!data)
	return -1;

    handle = info->handle;
    mc = info->conn;

    rpc_send (mc->sock, RPC_INT, MC_CLOSE, RPC_INT, handle, RPC_END);

    if (0 ==
	rpc_get (mc->sock, RPC_INT, &result, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    is_error (result, error);

    g_free (data);
    return result;
}

static int
mcfs_errno (vfs *me)
{
    return my_errno;
}

typedef struct dir_entry {
    char *text;
    struct dir_entry *next;
    struct stat my_stat;
    int merrno;
} dir_entry;

typedef struct {
    mcfs_connection *conn;
    int handle;
    dir_entry *entries;
    dir_entry *current;
} opendir_info;

static void *
mcfs_opendir (vfs *me, char *dirname)
{
    opendir_info *mcfs_info;
    mcfs_connection *mc;
    int handle, error_num;
    char *remote_dir;
    int result;

    if (!(remote_dir = mcfs_get_path (&mc, dirname)))
	return 0;

    rpc_send (mc->sock, RPC_INT, MC_OPENDIR, RPC_STRING, remote_dir,
	      RPC_END);
    g_free (remote_dir);

    if (0 ==
	rpc_get (mc->sock, RPC_INT, &result, RPC_INT, &error_num, RPC_END))
	return 0;

    if (is_error (result, error_num))
	return 0;

    handle = result;

    mcfs_info = g_new (opendir_info, 1);
    mcfs_info->conn = mc;
    mcfs_info->handle = handle;
    mcfs_info->entries = 0;
    mcfs_info->current = 0;

    return mcfs_info;
}

static int get_stat_info (mcfs_connection * mc, struct stat *buf);

static int
mcfs_loaddir (opendir_info *mcfs_info)
{
    int status, error;
    mcfs_connection *mc = mcfs_info->conn;
    int link = mc->sock;
    int first = 1;

    rpc_send (link, RPC_INT, MC_READDIR, RPC_INT, mcfs_info->handle,
	      RPC_END);

    for (;;) {
	int entry_len;
	dir_entry *new_entry;

	if (!rpc_get (link, RPC_INT, &entry_len, RPC_END))
	    return 0;

	if (entry_len == 0)
	    break;

	new_entry = g_new (dir_entry, 1);
	new_entry->text = g_new0 (char, entry_len + 1);

	new_entry->next = 0;
	if (first) {
	    mcfs_info->entries = new_entry;
	    mcfs_info->current = new_entry;
	    first = 0;
	} else {
	    mcfs_info->current->next = new_entry;
	    mcfs_info->current = new_entry;
	}

	if (!rpc_get
	    (link, RPC_BLOCK, entry_len, new_entry->text, RPC_END))
	    return 0;

	/* Then we get the status from the lstat */
	if (!rpc_get (link, RPC_INT, &status, RPC_INT, &error, RPC_END))
	    return 0;

	if (is_error (status, error))
	    new_entry->merrno = error;
	else {
	    new_entry->merrno = 0;
	    if (!get_stat_info (mc, &(new_entry->my_stat)))
		return 0;
	}
    }
    mcfs_info->current = mcfs_info->entries;

    return 1;
}

static void
mcfs_free_dir (dir_entry *de)
{
    if (!de)
	return;
    mcfs_free_dir (de->next);
    g_free (de->text);
    g_free (de);
}

static union vfs_dirent mcfs_readdir_data;

/* The readdir routine loads the complete directory */
/* It's too slow to ask the server each time */
/* It now also sends the complete lstat information for each file */
static struct stat *cached_lstat_info;

static void *
mcfs_readdir (void *info)
{
    opendir_info *mcfs_info;
    char *dirent_dest;

    mcfs_info = (opendir_info *) info;

    if (!mcfs_info->entries)
	if (!mcfs_loaddir (mcfs_info))
	    return NULL;

    if (mcfs_info->current == 0) {
	cached_lstat_info = 0;
	mcfs_free_dir (mcfs_info->entries);
	mcfs_info->entries = 0;
	return NULL;
    }
    dirent_dest = mcfs_readdir_data.dent.d_name;
    strncpy (dirent_dest, mcfs_info->current->text, MC_MAXPATHLEN);
    dirent_dest[MC_MAXPATHLEN] = 0;
    cached_lstat_info = &mcfs_info->current->my_stat;
    mcfs_info->current = mcfs_info->current->next;

    compute_namelen (&mcfs_readdir_data.dent);

    return &mcfs_readdir_data;
}

static int
mcfs_closedir (void *info)
{
    opendir_info *mcfs_info = (opendir_info *) info;
    dir_entry *p, *q;

    rpc_send (mcfs_info->conn->sock, RPC_INT, MC_CLOSEDIR,
	      RPC_INT, mcfs_info->handle, RPC_END);

    for (p = mcfs_info->entries; p;) {
	q = p;
	p = p->next;
	g_free (q->text);
	g_free (q);
    }
    g_free (info);
    return 0;
}

static time_t
mcfs_get_time (mcfs_connection *mc)
{
    int sock = mc->sock;

    if (mc->version == 1) {
	struct tm tt;

	rpc_get (sock,
		 RPC_INT, &tt.tm_sec,
		 RPC_INT, &tt.tm_min,
		 RPC_INT, &tt.tm_hour,
		 RPC_INT, &tt.tm_mday,
		 RPC_INT, &tt.tm_year, RPC_INT, &tt.tm_mon, RPC_END);
	tt.tm_year -= 1900;
	tt.tm_isdst = 0;

	return mktime (&tt);
    } else {
	char *buf;
	long tm;

	rpc_get (sock, RPC_STRING, &buf, RPC_END);
	sscanf (buf, "%lx", &tm);
	g_free (buf);

	return (time_t) tm;
    }
}

static int
get_stat_info (mcfs_connection *mc, struct stat *buf)
{
    long mylong;
    int sock = mc->sock;

    buf->st_dev = 0;

    rpc_get (sock, RPC_INT, &mylong, RPC_END);
#ifdef HAVE_ST_RDEV
    buf->st_rdev = mylong;
#endif
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_ino = mylong;
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_mode = mylong;
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_nlink = mylong;
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_uid = mylong;
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_gid = mylong;
    rpc_get (sock, RPC_INT, &mylong, RPC_END);
    buf->st_size = mylong;

    if (!rpc_get (sock, RPC_INT, &mylong, RPC_END))
	return 0;
#ifdef HAVE_ST_BLOCKS
    buf->st_blocks = mylong;
#endif
    buf->st_atime = mcfs_get_time (mc);
    buf->st_mtime = mcfs_get_time (mc);
    buf->st_ctime = mcfs_get_time (mc);
    return 1;
}

static int
mcfs_stat_cmd (int cmd, char *path, struct stat *buf)
{
    char *remote_file;
    mcfs_connection *mc;
    int status, error;

    if ((remote_file = mcfs_get_path (&mc, path)) == 0)
	return -1;

    rpc_send (mc->sock, RPC_INT, cmd, RPC_STRING, remote_file, RPC_END);
    g_free (remote_file);
    if (!rpc_get (mc->sock, RPC_INT, &status, RPC_INT, &error, RPC_END))
	return the_error (-1, errno);

    if (is_error (status, error))
	return -1;

    if (get_stat_info (mc, buf))
	return 0;
    else
	return the_error (-1, EIO);
}

static int
mcfs_stat (vfs *me, char *path, struct stat *buf)
{
    return mcfs_stat_cmd (MC_STAT, path, buf);
}

static int
mcfs_lstat (vfs *me, char *path, struct stat *buf)
{
    int path_len = strlen (path);
    int entry_len = strlen (mcfs_readdir_data.dent.d_name);

    /* Hack ... */
    if (strcmp (path + path_len - entry_len,
		mcfs_readdir_data.dent.d_name) == 0 && cached_lstat_info) {
	*buf = *cached_lstat_info;
	return 0;
    }
    return mcfs_stat_cmd (MC_LSTAT, path, buf);
}

static int
mcfs_fstat (void *data, struct stat *buf)
{
    mcfs_handle *info = (mcfs_handle *) data;
    int result, error;
    int handle, sock;

    sock = info->conn->sock;
    handle = info->handle;

    rpc_send (sock, RPC_INT, MC_FSTAT, RPC_INT, handle, RPC_END);
    if (!rpc_get (sock, RPC_INT, &result, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    if (is_error (result, error))
	return -1;

    if (get_stat_info (info->conn, buf))
	return 0;
    else
	return the_error (-1, EIO);
}

static int
mcfs_chmod (vfs *me, char *path, int mode)
{
    return mcfs_rpc_path_int (MC_CHMOD, path, mode);
}

static int
mcfs_chown (vfs *me, char *path, int owner, int group)
{
    return mcfs_rpc_path_int_int (MC_CHOWN, path, owner, group);
}

static int
mcfs_utime (vfs *me, char *path, struct utimbuf *times)
{
    mcfs_connection *mc;
    int status;
    char *file;

    if (!(file = mcfs_get_path (&mc, path)))
	return -1;

    status = 0;
    if (mc->version >= 2) {
	char abuf[BUF_SMALL];
	char mbuf[BUF_SMALL];
	long atime, mtime;

	atime = (long) times->actime;
	mtime = (long) times->modtime;

	g_snprintf (abuf, sizeof (abuf), "%lx", atime);
	g_snprintf (mbuf, sizeof (mbuf), "%lx", mtime);

	rpc_send (mc->sock, RPC_INT, MC_UTIME,
		  RPC_STRING, file,
		  RPC_STRING, abuf, RPC_STRING, mbuf, RPC_END);
	status = mcfs_handle_simple_error (mc->sock, 0);

    }
    g_free (file);
    return (status);
}

static int
mcfs_readlink (vfs *me, char *path, char *buf, int size)
{
    char *remote_file, *stat_str;
    int status, error;
    mcfs_connection *mc;

    if (!(remote_file = mcfs_get_path (&mc, path)))
	return -1;

    rpc_send (mc->sock, RPC_INT, MC_READLINK, RPC_STRING, remote_file,
	      RPC_END);
    g_free (remote_file);
    if (!rpc_get (mc->sock, RPC_INT, &status, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    if (is_error (status, errno))
	return -1;

    if (!rpc_get (mc->sock, RPC_STRING, &stat_str, RPC_END))
	return the_error (-1, EIO);

    status = strlen (stat_str);
    if (status < size)
	size = status;
    strncpy (buf, stat_str, size);
    g_free (stat_str);
    return size;
}

static int
mcfs_unlink (vfs *me, char *path)
{
    return mcfs_rpc_path (MC_UNLINK, path);
}

static int
mcfs_symlink (vfs *me, char *n1, char *n2)
{
    return mcfs_rpc_two_paths (MC_SYMLINK, n1, n2);
}

static int
mcfs_rename (vfs *me, char *a, char *b)
{
    return mcfs_rpc_two_paths (MC_RENAME, a, b);
}

static int
mcfs_chdir (vfs *me, char *path)
{
    char *remote_dir;
    mcfs_connection *mc;
    int status, error;

    if (!(remote_dir = mcfs_get_path (&mc, path)))
	return -1;

    rpc_send (mc->sock, RPC_INT, MC_CHDIR, RPC_STRING, remote_dir,
	      RPC_END);
    g_free (remote_dir);
    if (!rpc_get (mc->sock, RPC_INT, &status, RPC_INT, &error, RPC_END))
	return the_error (-1, EIO);

    if (is_error (status, error))
	return -1;
    return 0;
}

static int
mcfs_lseek (void *data, off_t offset, int whence)
{
    mcfs_handle *info = (mcfs_handle *) data;
    int handle, sock;

    sock = info->conn->sock;
    handle = info->handle;

    /* FIXME: off_t may be too long to fit */
    rpc_send (sock, RPC_INT, MC_LSEEK, RPC_INT, handle, RPC_INT,
	      (int) offset, RPC_INT, whence, RPC_END);

    return mcfs_handle_simple_error (sock, 1);
}

static int
mcfs_mknod (vfs *me, char *path, int mode, int dev)
{
    return mcfs_rpc_path_int_int (MC_MKNOD, path, mode, dev);
}

static int
mcfs_mkdir (vfs *me, char *path, mode_t mode)
{
    return mcfs_rpc_path_int (MC_MKDIR, path, mode);
}

static int
mcfs_rmdir (vfs *me, char *path)
{
    return mcfs_rpc_path (MC_RMDIR, path);
}

static int
mcfs_link (vfs *me, char *p1, char *p2)
{
    return mcfs_rpc_two_paths (MC_LINK, p1, p2);
}

/* We do not free anything right now: we free resources when we run
 * out of them
 */
static vfsid
mcfs_getid (vfs *me, char *p, struct vfs_stamping **parent)
{
    *parent = NULL;

    return (vfsid) - 1;
}

static int
mcfs_nothingisopen (vfsid id)
{
    return 0;
}

static void
mcfs_free (vfsid id)
{
    /* FIXME: Should not be empty */
}

/* Gives up on a socket and reopnes the connection, the child own the socket
 * now
 */
static void
my_forget (char *path)
{
    char *host, *user, *pass, *p;
    int port, i, vers;

    if (strncmp (path, "/#mc:", 5))
	return;

    path += 5;
    if (path[0] == '/' && path[1] == '/')
	path += 2;

    if ((p =
	 mcfs_get_host_and_username (path, &host, &user, &port,
				     &pass)) == 0) {
	g_free (host);
	g_free (user);
	if (pass)
	    wipe_password (pass);
	return;
    }
    for (i = 0; i < MCFS_MAX_CONNECTIONS; i++) {
	if ((strcmp (host, mcfs_connections[i].host) == 0) &&
	    (strcmp (user, mcfs_connections[i].user) == 0) &&
	    (port == mcfs_connections[i].port)) {

	    /* close socket: the child owns it now */
	    close (mcfs_connections[i].sock);

	    /* reopen the connection */
	    mcfs_connections[i].sock =
		mcfs_open_tcp_link (host, user, &port, pass, &vers);
	}
    }
    g_free (p);
    g_free (host);
    g_free (user);
    if (pass)
	wipe_password (pass);
}

static int
mcfs_setctl (vfs *me, char *path, int ctlop, char *arg)
{
    switch (ctlop) {
    case MCCTL_FORGET_ABOUT:
	my_forget (path);
	return 0;
    }
    return 0;
}

vfs vfs_mcfs_ops = {
    NULL,			/* This is place of next pointer */
    "mcfs",
    F_NET,			/* flags */
    "mc:",			/* prefix */
    NULL,			/* data */
    0,				/* errno */
    NULL,
    NULL,
    mcfs_fill_names,
    NULL,

    mcfs_open,
    mcfs_close,
    mcfs_read,
    mcfs_write,

    mcfs_opendir,
    mcfs_readdir,
    mcfs_closedir,
    NULL,
    NULL,

    mcfs_stat,
    mcfs_lstat,
    mcfs_fstat,

    mcfs_chmod,
    mcfs_chown,
    mcfs_utime,

    mcfs_readlink,
    mcfs_symlink,
    mcfs_link,
    mcfs_unlink,

    mcfs_rename,
    mcfs_chdir,
    mcfs_errno,
    mcfs_lseek,
    mcfs_mknod,

    mcfs_getid,
    mcfs_nothingisopen,
    mcfs_free,

    NULL,
    NULL,

    mcfs_mkdir,
    mcfs_rmdir,
    NULL,
    mcfs_setctl MMAPNULL
};


static void
mcfs_free_bucket (int bucket)
{
    g_free (mcfs_connections[bucket].host);
    g_free (mcfs_connections[bucket].user);
    g_free (mcfs_connections[bucket].home);

    /* Set all the fields to zero */
    mcfs_connections[bucket].host =
	mcfs_connections[bucket].user = mcfs_connections[bucket].home = 0;
    mcfs_connections[bucket].sock = mcfs_connections[bucket].version = 0;
}

static int
mcfs_invalidate_socket (int sock)
{
    int i, j = -1;

    for (i = 0; i < MCFS_MAX_CONNECTIONS; i++)
	if (mcfs_connections[i].sock == sock) {
	    mcfs_free_bucket (i);
	    j = 0;
	}

    if (j == -1)
	return -1;		/* It was not our sock */
    /* Break from any possible loop */
    mc_chdir ("/");
    return 0;
}

void
tcp_invalidate_socket (int sock)
{
    mcfs_invalidate_socket (sock);
}

#endif				/* WITH_MCFS */