/*
 * Copyright (c) 1997-2011 Erez Zadok
 * Copyright (c) 1990 Jan-Simon Pendry
 * Copyright (c) 1990 Imperial College of Science, Technology & Medicine
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry at Imperial College, London.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgment:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *
 * File: am-utils/conf/mount/mount_linux.c
 */

/*
 * Linux mount helper.
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <am_defs.h>
#include <amu.h>

#ifdef HAVE_RPC_AUTH_H
# include <rpc/auth.h>
#endif

#ifndef MOUNT_TYPE_UFS
/*
 * Autoconf didn't find any disk-based f/s on this system,
 * So provide some default definition for this file to compile.
 */
# define MOUNT_TYPE_UFS		"no_disk_fs"
#endif /* not MOUNT_TYPE_UFS */

struct opt_map {
  const char *opt;		/* option name */
  int inv;			/* true if flag value should be inverted */
  int mask;			/* flag mask value */
};

const struct opt_map opt_map[] =
{
  {"defaults",		0,	0},
  {MNTTAB_OPT_RO,	0,	MNT2_GEN_OPT_RDONLY},
  {MNTTAB_OPT_RW,	1,	MNT2_GEN_OPT_RDONLY},
  {MNTTAB_OPT_EXEC,	1,	MNT2_GEN_OPT_NOEXEC},
  {MNTTAB_OPT_NOEXEC,	0,	MNT2_GEN_OPT_NOEXEC},
  {MNTTAB_OPT_SUID,	1,	MNT2_GEN_OPT_NOSUID},
  {MNTTAB_OPT_NOSUID,	0,	MNT2_GEN_OPT_NOSUID},
#ifdef MNT2_GEN_OPT_NODEV
  {MNTTAB_OPT_NODEV,	0,	MNT2_GEN_OPT_NODEV},
#endif /* MNT2_GEN_OPT_NODEV */
#ifdef MNT2_GEN_OPT_SYNC
  {MNTTAB_OPT_SYNC,	0,	MNT2_GEN_OPT_SYNC},
  {MNTTAB_OPT_ASYNC,	1,	MNT2_GEN_OPT_SYNC},
#endif /* MNT2_GEN_OPT_SYNC */
#ifdef MNT2_GEN_OPT_NOSUB
  {MNTTAB_OPT_SUB,	1,	MNT2_GEN_OPT_NOSUB},
  {MNTTAB_OPT_NOSUB,	0,	MNT2_GEN_OPT_NOSUB},
#endif /* MNT2_GEN_OPT_NOSUB */
  {NULL,		0,	0}
};

struct fs_opts {
  const char *opt;
  int type;			/* XXX: Ion, what is this for? */
};

const struct fs_opts iso_opts[] = {
  { "map",	0 },
  { "norock",	0 },
  { "cruft",	0 },
  { "unhide",	0 },
  { "conv",	1 },
  { "block",	1 },
  { "mode",	1 },
  { "gid",	1 },
  { "uid",	1 },
  { NULL,	0 }
};

const struct fs_opts dos_opts[] = {
  { "check",	1 },
  { "conv",	1 },
  { "uid",	1 },
  { "gid",	1 },
  { "umask",	1 },
  { "debug",	0 },
  { "fat",	1 },
  { "quiet",	0 },
  { "blocksize",1 },
  { NULL,	0 }
};

const struct fs_opts autofs_opts[] = {
  { "fd",	1 },
  { "pgrp",	1 },
  { "minproto",	1 },
  { "maxproto",	1 },
  { NULL,	0 }
};

const struct fs_opts null_opts[] = {
  { NULL,	0 }
};


/*
 * New parser for linux-specific mounts.
 * Should now handle fs-type specific mount-options correctly.
 * Currently implemented: msdos, iso9660.
 */
static char *
parse_opts(char *type, const char *optstr, int *flags, char **xopts, int *noauto)
{
  const struct opt_map *std_opts;
  const struct fs_opts *dev_opts;
  char *opt, *topts, *xoptstr;
  size_t l;

  if (optstr == NULL)
    return NULL;

  xoptstr = strdup(optstr);	/* because strtok is destructive below */

  *noauto = 0;
  l = strlen(optstr) + 2;
  *xopts = (char *) xmalloc(l);
  topts = (char *) xmalloc(l);
  *topts = '\0';
  **xopts = '\0';

  for (opt = strtok(xoptstr, ","); opt; opt = strtok(NULL, ",")) {
    /*
     * First, parse standard options
     */
    std_opts = opt_map;
    while (std_opts->opt &&
	   !NSTREQ(std_opts->opt, opt, strlen(std_opts->opt)))
      ++std_opts;
    if (!(*noauto = STREQ(opt, MNTTAB_OPT_NOAUTO)) || std_opts->opt) {
      xstrlcat(topts, opt, l);
      xstrlcat(topts, ",", l);
      if (std_opts->inv)
	*flags &= ~std_opts->mask;
      else
	*flags |= std_opts->mask;
    }
    /*
     * Next, select which fs-type is to be used
     * and parse the fs-specific options
     */
#ifdef MOUNT_TYPE_AUTOFS
    if (STREQ(type, MOUNT_TYPE_AUTOFS)) {
      dev_opts = autofs_opts;
      goto do_opts;
    }
#endif /* MOUNT_TYPE_AUTOFS */
#ifdef MOUNT_TYPE_PCFS
    if (STREQ(type, MOUNT_TYPE_PCFS)) {
      dev_opts = dos_opts;
      goto do_opts;
    }
#endif /* MOUNT_TYPE_PCFS */
#ifdef MOUNT_TYPE_CDFS
    if (STREQ(type, MOUNT_TYPE_CDFS)) {
      dev_opts = iso_opts;
      goto do_opts;
    }
#endif /* MOUNT_TYPE_CDFS */
#ifdef MOUNT_TYPE_LOFS
    if (STREQ(type, MOUNT_TYPE_LOFS)) {
      dev_opts = null_opts;
      goto do_opts;
    }
#endif /* MOUNT_TYPE_LOFS */
    plog(XLOG_FATAL, "linux mount: unknown fs-type: %s\n", type);
    XFREE(xoptstr);
    XFREE(*xopts);
    XFREE(topts);
    return NULL;

do_opts:
    while (dev_opts->opt &&
	   (!NSTREQ(dev_opts->opt, opt, strlen(dev_opts->opt)))) {
      ++dev_opts;
    }
    if (dev_opts->opt && *xopts) {
      xstrlcat(*xopts, opt, l);
      xstrlcat(*xopts, ",", l);
    }
  }
  /*
   * All other options are discarded
   */
  if (strlen(*xopts))
    *(*xopts + strlen(*xopts)-1) = '\0';
  if (strlen(topts))
    topts[strlen(topts)-1] = '\0';
  XFREE(xoptstr);
  return topts;
}


/*
 * Returns combined linux kernel version number.  For a kernel numbered
 * x.y.z, returns x*65535+y*256+z.
 */
int
linux_version_code(void)
{
  struct utsname my_utsname;
  static int release = 0;

  if ( 0 == release && 0 == uname(&my_utsname)) {
    release = 65536 * atoi(strtok(my_utsname.release, "."))
      + 256 * atoi(strtok(NULL, "."))
      + atoi(strtok(NULL, "."));
  }
  return release;
}


int
do_mount_linux(MTYPE_TYPE type, mntent_t *mnt, int flags, caddr_t data)
{
  if (amuDebug(D_FULL)) {
    plog(XLOG_DEBUG, "do_mount_linux: fsname %s\n", mnt->mnt_fsname);
    plog(XLOG_DEBUG, "do_mount_linux: type (mntent) %s\n", mnt->mnt_type);
    plog(XLOG_DEBUG, "do_mount_linux: opts %s\n", mnt->mnt_opts);
    plog(XLOG_DEBUG, "do_mount_linux: dir %s\n", mnt->mnt_dir);
  }

  /*
   * If we have an nfs mount, the 5th argument to system mount() must be the
   * nfs_mount_data structure, otherwise it is the return from parse_opts()
   */
  return mount(mnt->mnt_fsname,
	       mnt->mnt_dir,
	       type,
	       MS_MGC_VAL | flags,
	       data);
}


int
mount_linux_nfs(MTYPE_TYPE type, mntent_t *mnt, int flags, caddr_t data)
{
  nfs_args_t *mnt_data = (nfs_args_t *) data;
  int errorcode;

  /* Fake some values for linux */
  mnt_data->version = NFS_MOUNT_VERSION;
  if (!mnt_data->timeo) {
#ifdef MNT2_NFS_OPT_TCP
    if (mnt_data->flags & MNT2_NFS_OPT_TCP)
      mnt_data->timeo = 600;
    else
#endif /* MNT2_NFS_OPT_TCP */
      mnt_data->timeo = 7;
  }
  if (!mnt_data->retrans)
    mnt_data->retrans = 3;

#ifdef MNT2_NFS_OPT_NOAC
  if (!(mnt_data->flags & MNT2_NFS_OPT_NOAC)) {
    if (!(mnt_data->flags & MNT2_NFS_OPT_ACREGMIN))
      mnt_data->acregmin = 3;
    if (!(mnt_data->flags & MNT2_NFS_OPT_ACREGMAX))
      mnt_data->acregmax = 60;
    if (!(mnt_data->flags & MNT2_NFS_OPT_ACDIRMIN))
      mnt_data->acdirmin = 30;
    if (!(mnt_data->flags & MNT2_NFS_OPT_ACDIRMAX))
      mnt_data->acdirmax = 60;
  }
#endif /* MNT2_NFS_OPT_NOAC */

  /*
   * in nfs structure implementation version 4, the old
   * filehandle field was renamed "old_root" and left as 3rd field,
   * while a new field called "root" was added to the end of the
   * structure. Both of them however need a copy of the file handle
   * for NFSv2 mounts.
   */
#ifdef MNT2_NFS_OPT_VER3
  if (mnt_data->flags & MNT2_NFS_OPT_VER3)
    memset(mnt_data->old_root.data, 0, FHSIZE);
  else
#endif /* MNT2_NFS_OPT_VER3 */
    memcpy(mnt_data->old_root.data, mnt_data->root.data, FHSIZE);

#ifdef HAVE_NFS_ARGS_T_BSIZE
  /* linux mount version 3 */
  mnt_data->bsize = 0;			/* let the kernel decide */
#endif /* HAVE_NFS_ARGS_T_BSIZE */

#ifdef HAVE_NFS_ARGS_T_NAMLEN
  /* linux mount version 2 */
  mnt_data->namlen = NAME_MAX;		/* 256 bytes */
#endif /* HAVE_NFS_ARGS_T_NAMELEN */

#ifdef HAVE_NFS_ARGS_T_PSEUDOFLAVOR
# ifdef HAVE_RPC_AUTH_H
  mnt_data->pseudoflavor = AUTH_UNIX;
# else
  mnt_data->pseudoflavor = 0;
# endif
#endif /* HAVE_NFS_ARGS_T_PSEUDOFLAVOR */

#ifdef HAVE_NFS_ARGS_T_CONTEXT
  memset(mnt_data->context, 0, sizeof(mnt_data->context));
#endif /* HAVE_NFS_ARGS_T_CONTEXT */

  mnt_data->fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  if (mnt_data->fd < 0) {
    plog(XLOG_ERROR, "Can't create socket for kernel");
    return 1;
  }
  if (bindresvport(mnt_data->fd, NULL) < 0) {
    plog(XLOG_ERROR, "Can't bind to reserved port");
    errorcode = 1;
    goto out;
  }
  /*
   * connect() the socket for kernels 1.3.10 and below
   * only to avoid problems with multihomed hosts.
   */
  if (linux_version_code() <= 0x01030a) {
    int ret = connect(mnt_data->fd,
		      (struct sockaddr *) &mnt_data->addr,
		      sizeof(mnt_data->addr));
    if (ret < 0) {
      plog(XLOG_ERROR, "Can't connect socket for kernel");
      errorcode = 1;
      goto out;
    }
  }
  if (amuDebug(D_FULL)) {
    plog(XLOG_DEBUG, "mount_linux_nfs: type %s\n", type);
    plog(XLOG_DEBUG, "mount_linux_nfs: version %d\n", mnt_data->version);
    plog(XLOG_DEBUG, "mount_linux_nfs: fd %d\n", mnt_data->fd);
    plog(XLOG_DEBUG, "mount_linux_nfs: hostname %s\n",
	 inet_ntoa(mnt_data->addr.sin_addr));
    plog(XLOG_DEBUG, "mount_linux_nfs: port %d\n",
	 htons(mnt_data->addr.sin_port));
  }
  if (amuDebug(D_TRACE)) {
    plog(XLOG_DEBUG, "mount_linux_nfs: Generic mount flags 0x%x", MS_MGC_VAL | flags);
    plog(XLOG_DEBUG, "mount_linux_nfs: updated nfs_args...");
    print_nfs_args(mnt_data, 0);
  }

  mnt_data->flags &= MNT2_NFS_OPT_FLAGMASK;

  errorcode = do_mount_linux(type, mnt, flags, data);

 out:
  /*
   * If we failed, (i.e. errorcode != 0), then close the socket
   * if it is open.
   */
  if (errorcode && mnt_data->fd != -1) {
    /* save errno, may be clobbered by close() call! */
    int save_errno = errno;
    close(mnt_data->fd);
    errno = save_errno;
  }
  return errorcode;
}


int
mount_linux_nonfs(MTYPE_TYPE type, mntent_t *mnt, int flags, caddr_t data)
{
  char *extra_opts = NULL;
  char *tmp_opts = NULL;
  char *sub_type = NULL;
  char *loopdev = NULL;
  int noauto = 0;
  int errorcode;

  sub_type = hasmnteq(mnt, "type");
  if (sub_type) {
    sub_type = strdup(sub_type);
    if (sub_type) {		/* the strdup malloc might have failed */
      type = strpbrk(sub_type, ",:;\n\t");
      if (type == NULL)
	type = MOUNT_TYPE_UFS;
      else {
	*type = '\0';
	type = sub_type;
      }
    } else {
      plog(XLOG_ERROR, "strdup returned null in mount_linux_nonfs");
    }
  }

  if (!hasmntopt(mnt, "type"))
    mnt->mnt_type = type;

  tmp_opts = parse_opts(type, mnt->mnt_opts, &flags, &extra_opts, &noauto);

#ifdef MOUNT_TYPE_LOFS
  if (STREQ(type, MOUNT_TYPE_LOFS)) {
# ifndef MNT2_GEN_OPT_BIND
    size_t l;
    /* this is basically a hack to support fist lofs */
    XFREE(extra_opts);
    l = strlen(mnt->mnt_fsname) + sizeof("dir=") + 1;
    extra_opts = (char *) xmalloc(l);
    xsnprintf(extra_opts, l, sizeof(extra_opts), "dir=%s", mnt->mnt_fsname);
# else /* MNT2_GEN_OPT_BIND */
    /* use bind mounts for lofs */
    flags |= MNT2_GEN_OPT_BIND;
# endif /* MNT2_GEN_OPT_BIND */
    errorcode = do_mount_linux(type, mnt, flags, extra_opts);
  } else /* end of "if type is LOFS" */
#endif /* MOUNT_TYPE_LOFS */

  {
#ifdef HAVE_LOOP_DEVICE
    /*
     * If the mounted "device" is actually a regular file,
     # try to attach a loop device to it.
     */
    struct stat buf;
    char *old_fsname = NULL;
    if (stat(mnt->mnt_fsname, &buf) == 0 &&
	S_ISREG(buf.st_mode)) {
      if ((loopdev = setup_loop_device(mnt->mnt_fsname)) != NULL) {
	char *str;
	size_t l;

	plog(XLOG_INFO, "setup loop device %s over %s OK", loopdev, mnt->mnt_fsname);
	old_fsname = mnt->mnt_fsname;
	mnt->mnt_fsname = loopdev;
	/* XXX: hack, append loop=/dev/loopX to mnttab opts */
	l = strlen(mnt->mnt_opts) + 7 + strlen(loopdev);
	str = (char *) xmalloc(l);
	if (str) {
	  xsnprintf(str, l, "%s,loop=%s", mnt->mnt_opts, loopdev);
	  XFREE(mnt->mnt_opts);
	  mnt->mnt_opts = str;
	}
      } else {
	plog(XLOG_ERROR, "failed to set up a loop device: %m");
	errorcode = 1;
	goto out;
      }
    }
#endif /* HAVE_LOOP_DEVICE */

    errorcode = do_mount_linux(type, mnt, flags, extra_opts);

#ifdef HAVE_LOOP_DEVICE
    /* if mount failed and we used a loop device, then undo it */
    if (errorcode != 0 && loopdev != NULL) {
      if (delete_loop_device(loopdev) < 0)
	plog(XLOG_WARNING, "mount() failed to release loop device %s: %m", loopdev);
      else
	plog(XLOG_INFO, "mount() released loop device %s OK", loopdev);
    }
    if (old_fsname)
      mnt->mnt_fsname = old_fsname;
#endif /* HAVE_LOOP_DEVICE */
  }

  /*
   * Free all allocated space and return errorcode.
   */
out:
if (loopdev)
     XFREE(loopdev);
  if (extra_opts != NULL)
    XFREE(extra_opts);
  if (tmp_opts != NULL)
    XFREE(tmp_opts);
  if (sub_type != NULL)
    XFREE(sub_type);
  return errorcode;
}


int
mount_linux(MTYPE_TYPE type, mntent_t *mnt, int flags, caddr_t data)
{
  int errorcode;

  if (mnt->mnt_opts && STREQ(mnt->mnt_opts, "defaults"))
    mnt->mnt_opts = NULL;

  if (type == NULL)
    type = index(mnt->mnt_fsname, ':') ? MOUNT_TYPE_NFS : MOUNT_TYPE_UFS;

  if (STREQ(type, MOUNT_TYPE_NFS))
    errorcode = mount_linux_nfs(type, mnt, flags, data);
  else				/* non-NFS mounts */
    errorcode = mount_linux_nonfs(type, mnt, flags, data);

  return errorcode;
}


/****************************************************************************/
/*
 * NFS error numbers and Linux errno's are two different things!  Linux is
 * `worse' than other OSes in the respect that it loudly complains about
 * undefined NFS return value ("bad NFS return value..").  So we should
 * translate ANY possible Linux errno to their NFS equivalent.  Just, there
 * aren't much NFS numbers, so most go to EINVAL or EIO.  The mapping below
 * should fit at least for Linux/i386 and Linux/68k.  I haven't checked
 * other architectures yet.
 */

#define NE_PERM		1
#define NE_NOENT	2
#define NE_IO		5
#define NE_NXIO		6
#define NE_AGAIN	11
#define NE_ACCES	13
#define NE_EXIST	17
#define NE_NODEV	19
#define NE_NOTDIR	20
#define NE_ISDIR	21
#define NE_INVAL	22
#define NE_FBIG		27
#define NE_NOSPC	28
#define NE_ROFS		30
#define NE_OPNOTSUPP	45
#define NE_NAMETOOLONG	63
#define NE_NOTEMPTY	66
#define NE_DQUOT	69
#define NE_STALE	70
#define NE_REMOTE	71

#define NFS_LOMAP	0
#define NFS_HIMAP	122

/*
 * The errno's below are correct for Linux/i386. One day, somebody
 * with lots of energy ought to verify them against the other ports...
 */
static int nfs_errormap[] = {
	0,		/* success(0)		*/
	NE_PERM,	/* EPERM (1)		*/
	NE_NOENT,	/* ENOENT (2)		*/
	NE_INVAL,	/* ESRCH (3)		*/
	NE_IO,		/* EINTR (4)		*/
	NE_IO,		/* EIO (5)		*/
	NE_NXIO,	/* ENXIO (6)		*/
	NE_INVAL,	/* E2BIG (7)		*/
	NE_INVAL,	/* ENOEXEC (8)		*/
	NE_INVAL,	/* EBADF (9)		*/
	NE_IO,		/* ECHILD (10)		*/
	NE_AGAIN,	/* EAGAIN (11)		*/
	NE_IO,		/* ENOMEM (12)		*/
	NE_ACCES,	/* EACCES (13)		*/
	NE_INVAL,	/* EFAULT (14)		*/
	NE_INVAL,	/* ENOTBLK (15)		*/
	NE_IO,		/* EBUSY (16)		*/
	NE_EXIST,	/* EEXIST (17)		*/
	NE_INVAL,	/* EXDEV (18)		*/
	NE_NODEV,	/* ENODEV (19)		*/
	NE_NOTDIR,	/* ENOTDIR (20)		*/
	NE_ISDIR,	/* EISDIR (21)		*/
	NE_INVAL,	/* EINVAL (22)		*/
	NE_IO,		/* ENFILE (23)		*/
	NE_IO,		/* EMFILE (24)		*/
	NE_INVAL,	/* ENOTTY (25)		*/
	NE_ACCES,	/* ETXTBSY (26)		*/
	NE_FBIG,	/* EFBIG (27)		*/
	NE_NOSPC,	/* ENOSPC (28)		*/
	NE_INVAL,	/* ESPIPE (29)		*/
	NE_ROFS,	/* EROFS (30)		*/
	NE_INVAL,	/* EMLINK (31)		*/
	NE_INVAL,	/* EPIPE (32)		*/
	NE_INVAL,	/* EDOM (33)		*/
	NE_INVAL,	/* ERANGE (34)		*/
	NE_INVAL,	/* EDEADLK (35)		*/
	NE_NAMETOOLONG,	/* ENAMETOOLONG (36)	*/
	NE_INVAL,	/* ENOLCK (37)		*/
	NE_INVAL,	/* ENOSYS (38)		*/
	NE_NOTEMPTY,	/* ENOTEMPTY (39)	*/
	NE_INVAL,	/* ELOOP (40)		*/
	NE_INVAL,	/* unused (41)		*/
	NE_INVAL,	/* ENOMSG (42)		*/
	NE_INVAL,	/* EIDRM (43)		*/
	NE_INVAL,	/* ECHRNG (44)		*/
	NE_INVAL,	/* EL2NSYNC (45)	*/
	NE_INVAL,	/* EL3HLT (46)		*/
	NE_INVAL,	/* EL3RST (47)		*/
	NE_INVAL,	/* ELNRNG (48)		*/
	NE_INVAL,	/* EUNATCH (49)		*/
	NE_INVAL,	/* ENOCSI (50)		*/
	NE_INVAL,	/* EL2HLT (51)		*/
	NE_INVAL,	/* EBADE (52)		*/
	NE_INVAL,	/* EBADR (53)		*/
	NE_INVAL,	/* EXFULL (54)		*/
	NE_INVAL,	/* ENOANO (55)		*/
	NE_INVAL,	/* EBADRQC (56)		*/
	NE_INVAL,	/* EBADSLT (57)		*/
	NE_INVAL,	/* unused (58)		*/
	NE_INVAL,	/* EBFONT (59)		*/
	NE_INVAL,	/* ENOSTR (60)		*/
	NE_INVAL,	/* ENODATA (61)		*/
	NE_INVAL,	/* ETIME (62)		*/
	NE_INVAL,	/* ENOSR (63)		*/
	NE_INVAL,	/* ENONET (64)		*/
	NE_INVAL,	/* ENOPKG (65)		*/
	NE_INVAL,	/* EREMOTE (66)		*/
	NE_INVAL,	/* ENOLINK (67)		*/
	NE_INVAL,	/* EADV (68)		*/
	NE_INVAL,	/* ESRMNT (69)		*/
	NE_IO,		/* ECOMM (70)		*/
	NE_IO,		/* EPROTO (71)		*/
	NE_IO,		/* EMULTIHOP (72)	*/
	NE_IO,		/* EDOTDOT (73)		*/
	NE_INVAL,	/* EBADMSG (74)		*/
	NE_INVAL,	/* EOVERFLOW (75)	*/
	NE_INVAL,	/* ENOTUNIQ (76)	*/
	NE_INVAL,	/* EBADFD (77)		*/
	NE_IO,		/* EREMCHG (78)		*/
	NE_IO,		/* ELIBACC (79)		*/
	NE_IO,		/* ELIBBAD (80)		*/
	NE_IO,		/* ELIBSCN (81)		*/
	NE_IO,		/* ELIBMAX (82)		*/
	NE_IO,		/* ELIBEXEC (83)	*/
	NE_INVAL,	/* EILSEQ (84)		*/
	NE_INVAL,	/* ERESTART (85)	*/
	NE_INVAL,	/* ESTRPIPE (86)	*/
	NE_INVAL,	/* EUSERS (87)		*/
	NE_INVAL,	/* ENOTSOCK (88)	*/
	NE_INVAL,	/* EDESTADDRREQ (89)	*/
	NE_INVAL,	/* EMSGSIZE (90)	*/
	NE_INVAL,	/* EPROTOTYPE (91)	*/
	NE_INVAL,	/* ENOPROTOOPT (92)	*/
	NE_INVAL,	/* EPROTONOSUPPORT (93) */
	NE_INVAL,	/* ESOCKTNOSUPPORT (94) */
	NE_INVAL,	/* EOPNOTSUPP (95)	*/
	NE_INVAL,	/* EPFNOSUPPORT (96)	*/
	NE_INVAL,	/* EAFNOSUPPORT (97)	*/
	NE_INVAL,	/* EADDRINUSE (98)	*/
	NE_INVAL,	/* EADDRNOTAVAIL (99)	*/
	NE_IO,		/* ENETDOWN (100)	*/
	NE_IO,		/* ENETUNREACH (101)	*/
	NE_IO,		/* ENETRESET (102)	*/
	NE_IO,		/* ECONNABORTED (103)	*/
	NE_IO,		/* ECONNRESET (104)	*/
	NE_IO,		/* ENOBUFS (105)	*/
	NE_IO,		/* EISCONN (106)	*/
	NE_IO,		/* ENOTCONN (107)	*/
	NE_IO,		/* ESHUTDOWN (108)	*/
	NE_IO,		/* ETOOMANYREFS (109)	*/
	NE_IO,		/* ETIMEDOUT (110)	*/
	NE_IO,		/* ECONNREFUSED (111)	*/
	NE_IO,		/* EHOSTDOWN (112)	*/
	NE_IO,		/* EHOSTUNREACH (113)	*/
	NE_IO,		/* EALREADY (114)	*/
	NE_IO,		/* EINPROGRESS (115)	*/
	NE_STALE,	/* ESTALE (116)		*/
	NE_IO,		/* EUCLEAN (117)	*/
	NE_INVAL,	/* ENOTNAM (118)	*/
	NE_INVAL,	/* ENAVAIL (119)	*/
	NE_INVAL,	/* EISNAM (120)		*/
	NE_IO,		/* EREMOTEIO (121)	*/
	NE_DQUOT,	/* EDQUOT (122)		*/
};


int
linux_nfs_error(int e)
{
  int ret = (nfsstat) NE_IO;

  if (e < NFS_LOMAP || e > NFS_HIMAP)
    ret = (nfsstat) NE_IO;
  else
    ret = nfs_errormap[e - NFS_LOMAP];
  dlog("linux_nfs_error: map error %d to NFS error %d", e, ret);
  return (nfsstat) ret;
}


#ifdef HAVE_LOOP_DEVICE
/****************************************************************************/
/*** LOOP DEVICE SUPPORT						  ***/
/*** Loop Device setup code taken from mount-2.11g-5.src.rpm, which was   ***/
/*** originally written bt Ted T'so and others.				  ***/
/****************************************************************************/

#define PROC_DEVICES	"/proc/devices"

#if not_used_yet
static int
show_loop(char *device)
{
  struct loop_info loopinfo;
  int fd;

  if ((fd = open(device, O_RDONLY)) < 0) {
    dlog("loop: can't open device %s: %m", device);
    return -2;
  }
  if (ioctl(fd, LOOP_GET_STATUS, &loopinfo) < 0) {
    dlog("loop: can't get info on device %s: %m", device);
    close(fd);
    return -1;
  }
  dlog("show_loop: %s: [%04x]:%ld (%s)",
       device, loopinfo.lo_device, loopinfo.lo_inode,
       loopinfo.lo_name);

  close(fd);

  return 0;
}


static int
is_loop_device(const char *device)
{
  struct stat statbuf;
  int loopmajor = 7;

  return (loopmajor && stat(device, &statbuf) == 0 &&
	  S_ISBLK(statbuf.st_mode) &&
	  (statbuf.st_rdev>>8) == loopmajor);
}
#endif /* not_used_yet */


/*
 * Just creating a device, say in /tmp, is probably a bad idea - people
 * might have problems with backup or so.  So, we just try /dev/loop[0-7].
 */
static char *
find_unused_loop_device(void)
{
  char dev[20];
  char *loop_formats[] = { "/dev/loop%d", "/dev/loop/%d" };
  int i, j, fd, somedev = 0, someloop = 0, loop_known = 0;
  struct stat statbuf;
  struct loop_info loopinfo;
  FILE *procdev;

#define LOOP_FMT_SIZE(a) (sizeof(a)/sizeof(a[0]))
  for (j = 0; j < (int) LOOP_FMT_SIZE(loop_formats); j++) {
    for (i = 0; i < 256; i++) {
      xsnprintf(dev, sizeof(dev), loop_formats[j], i);
      if (stat(dev, &statbuf) == 0 && S_ISBLK(statbuf.st_mode)) {
	somedev++;
	fd = open(dev, O_RDONLY);
	if (fd >= 0) {
	  if (ioctl(fd, LOOP_GET_STATUS, &loopinfo) == 0)
	    someloop++;		/* in use */
	  else if (errno == ENXIO) {
	    close(fd);
	    return strdup(dev); /* probably free */
	  }
	  close(fd);
	}
	continue;		/* continue trying as long as devices exist */
      }
      break;
    }
  }

  /* Nothing found. Why not? */
  if ((procdev = fopen(PROC_DEVICES, "r")) != NULL) {
    char line[100];
    while (fgets(line, sizeof(line), procdev))
      if (strstr(line, " loop\n")) {
	loop_known = 1;
	break;
      }
    fclose(procdev);
    if (!loop_known)
      loop_known = -1;
  }

  if (!somedev) {
    dlog("Could not find any device /dev/loop#");
  } else if (!someloop) {
    if (loop_known == 1) {
      dlog("Could not find any loop device.");
      dlog("...Maybe /dev/loop# has a wrong major number?");
    }
    else if (loop_known == -1) {
      dlog("Could not find any loop device, and, according to %s,", PROC_DEVICES);
      dlog("...this kernel does not know about the loop device.");
      dlog("... (If so, then recompile or `insmod loop.o'.)");
    } else {
      dlog("Could not find any loop device. Maybe this kernel does not know,");
      dlog("...about the loop device (then recompile or `insmod loop.o'), or");
      dlog("...maybe /dev/loop# has the wrong major number?");
    }
  } else {
    dlog("Could not find any free loop device!");
  }
  return NULL;
}


/* returns 0 if OK, -1 otherwise */
char *
setup_loop_device(const char *file)
{
  struct loop_info loopinfo;
  int fd, ffd, mode, err = -1;
  char *device = find_unused_loop_device();

  if (!device) {
    dlog("no unused loop device");
    goto out;
  }

  mode = O_RDWR | O_LARGEFILE;
  if ((ffd = open(file, mode)) < 0) {
    if (errno == EROFS) {
      mode = O_RDONLY | O_LARGEFILE;
      ffd = open(file, mode);
    }
    if (ffd < 0) {
      dlog("%s: %m", file);
      goto out;
    }
  }
  if ((fd = open(device, mode)) < 0) {
    dlog("%s: %m", device);
    goto out_close;
  }

  memset(&loopinfo, 0, sizeof(loopinfo));
  xstrlcpy(loopinfo.lo_name, file, LO_NAME_SIZE);
  loopinfo.lo_offset = 0;

  if (ioctl(fd, LOOP_SET_FD, ffd) < 0) {
    dlog("ioctl: LOOP_SET_FD: %m");
    goto out_close_all;
  }
  if (ioctl(fd, LOOP_SET_STATUS, &loopinfo) < 0) {
    (void) ioctl(fd, LOOP_CLR_FD, 0);
    dlog("ioctl: LOOP_SET_STATUS: %m");
    goto out_close_all;
  }

  /* if gets here, all is OK */
  err = 0;

out_close_all:
  close(fd);
out_close:
  close(ffd);
out:

  if (err) {
    XFREE(device);
    return NULL;
  } else {
    dlog("setup_loop_device(%s,%s): success", device, file);
    return device;
  }
}


int
delete_loop_device(const char *device)
{
  int fd;

  if ((fd = open(device, O_RDONLY)) < 0) {
    dlog("delete_loop_device: can't delete device %s: %m", device);
    return -1;
  }
  if (ioctl(fd, LOOP_CLR_FD, 0) < 0) {
    dlog("ioctl: LOOP_CLR_FD: %m");
    return -1;
  }
  close(fd);
  dlog("delete_loop_device(%s): success", device);
  return 0;
}
#endif /* HAVE_LOOP_DEVICE */


/****************************************************************************/
