716 lines
15 KiB
C
716 lines
15 KiB
C
/*
|
|
* User-level NFS server for DOS filesystems.
|
|
*/
|
|
#include <syslog.h>
|
|
#include <rpc/rpc.h>
|
|
#include <sys/errno.h>
|
|
#include "dos_fs.h"
|
|
|
|
#define as_attributes attrstat_u.attributes
|
|
#define dr_attributes diropres_u.diropres.attributes
|
|
#define dr_file diropres_u.diropres.file
|
|
#define rlr_data readlinkres_u.data
|
|
#define rr_data readres_u.reply.data
|
|
#define rr_attributes readres_u.reply.attributes
|
|
#define rdr_entries readdirres_u.reply.entries
|
|
#define rdr_eof readdirres_u.reply.eof
|
|
#define sfr_reply statfsres_u.reply
|
|
|
|
#define AUP(rq) ((struct authunix_parms *) (rq)->rq_clntcred)
|
|
|
|
#define errno_to_nfsstat(errno) \
|
|
((unsigned)(errno) > LASTERRNO ? NFSERR_IO : nfs_statmap[errno])
|
|
|
|
static enum nfsstat nfs_statmap[] = {
|
|
NFS_OK, /* 0 */
|
|
NFSERR_PERM, /* EPERM = 1 */
|
|
NFSERR_NOENT, /* ENOENT = 2 */
|
|
NFSERR_IO, /* ESRCH = 3 */
|
|
NFSERR_IO, /* EINTR = 4 */
|
|
NFSERR_IO, /* EIO = 5 */
|
|
NFSERR_NXIO, /* ENXIO = 6 */
|
|
NFSERR_IO, /* E2BIG = 7 */
|
|
NFSERR_IO, /* ENOEXEC = 8 */
|
|
NFSERR_IO, /* EBADF = 9 */
|
|
NFSERR_IO, /* ECHILD = 10 */
|
|
NFSERR_IO, /* EAGAIN = 11 */
|
|
NFSERR_IO, /* ENOMEM = 12 */
|
|
NFSERR_ACCES, /* EACCES = 13 */
|
|
NFSERR_IO, /* EFAULT = 14 */
|
|
NFSERR_IO, /* ENOTBLK = 15 */
|
|
NFSERR_IO, /* EBUSY = 16 */
|
|
NFSERR_EXIST, /* EEXIST = 17 */
|
|
NFSERR_IO, /* EXDEV = 18 */
|
|
NFSERR_NODEV, /* ENODEV = 19 */
|
|
NFSERR_NOTDIR, /* ENOTDIR = 20 */
|
|
NFSERR_ISDIR, /* EISDIR = 21 */
|
|
NFSERR_IO, /* EINVAL = 22 */
|
|
NFSERR_IO, /* ENFILE = 23 */
|
|
NFSERR_IO, /* EMFILE = 24 */
|
|
NFSERR_IO, /* ENOTTY = 25 */
|
|
NFSERR_IO, /* ETXTBSY = 26 */
|
|
NFSERR_FBIG, /* EFBIG = 27 */
|
|
NFSERR_NOSPC, /* ENOSPC = 28 */
|
|
NFSERR_IO, /* ESPIPE = 29 */
|
|
NFSERR_ROFS, /* EROFS = 30 */
|
|
(enum nfsstat) 31, /* EMLINK = 31 */
|
|
NFSERR_IO, /* EPIPE = 32 */
|
|
NFSERR_IO, /* EDOM = 33 */
|
|
NFSERR_IO, /* ERANGE = 34 */
|
|
NFSERR_IO, /* ENOMSG = 35 */
|
|
NFSERR_IO, /* EIDRM = 36 */
|
|
NFSERR_IO, /* ECHRNG = 37 */
|
|
NFSERR_IO, /* EL2NSYNC = 38 */
|
|
NFSERR_IO, /* EL3HLT = 39 */
|
|
NFSERR_IO, /* EL3RST = 40 */
|
|
NFSERR_IO, /* ELNRNG = 41 */
|
|
NFSERR_IO, /* EUNATCH = 42 */
|
|
NFSERR_IO, /* ENOCSI = 43 */
|
|
NFSERR_IO, /* EL2HLT = 44 */
|
|
NFSERR_IO, /* EDEADLK = 45 */
|
|
NFSERR_IO, /* ENOLCK = 46 */
|
|
NFSERR_IO, /* 47 */
|
|
NFSERR_IO, /* 48 */
|
|
NFSERR_IO, /* 49 */
|
|
NFSERR_IO, /* EBADE = 50 */
|
|
NFSERR_IO, /* EBADR = 51 */
|
|
NFSERR_IO, /* EXFULL = 52 */
|
|
NFSERR_IO, /* ENOANO = 53 */
|
|
NFSERR_IO, /* EBADRQC = 54 */
|
|
NFSERR_IO, /* EBADSLT = 55 */
|
|
NFSERR_IO, /* EDEADLOCK = 56 */
|
|
NFSERR_IO, /* EBFONT = 57 */
|
|
NFSERR_IO, /* 58 */
|
|
NFSERR_IO, /* 59 */
|
|
NFSERR_IO, /* ENOSTR = 60 */
|
|
NFSERR_IO, /* ENODATA = 61 */
|
|
NFSERR_IO, /* ETIME = 62 */
|
|
NFSERR_IO, /* ENOSR = 63 */
|
|
NFSERR_IO, /* ENONET = 64 */
|
|
NFSERR_IO, /* ENOPKG = 65 */
|
|
NFSERR_IO, /* EREMOTE = 66 */
|
|
NFSERR_IO, /* ENOLINK = 67 */
|
|
NFSERR_IO, /* EADV = 68 */
|
|
NFSERR_IO, /* ESRMNT = 69 */
|
|
NFSERR_IO, /* ECOMM = 70 */
|
|
NFSERR_IO, /* EPROTO = 71 */
|
|
NFSERR_IO, /* 72 */
|
|
NFSERR_IO, /* 73 */
|
|
NFSERR_IO, /* EMULTIHOP = 74 */
|
|
NFSERR_IO, /* ELBIN = 75 */
|
|
NFSERR_IO, /* EDOTDOT = 76 */
|
|
NFSERR_IO, /* EBADMSG = 77 */
|
|
NFSERR_IO, /* 78 */
|
|
NFSERR_IO, /* 79 */
|
|
NFSERR_IO, /* ENOTUNIQ = 80 */
|
|
NFSERR_IO, /* EBADFD = 81 */
|
|
NFSERR_IO, /* EREMCHG = 82 */
|
|
NFSERR_IO, /* ELIBACC = 83 */
|
|
NFSERR_IO, /* ELIBBAD = 84 */
|
|
NFSERR_IO, /* ELIBSCN = 85 */
|
|
NFSERR_IO, /* ELIBMAX = 86 */
|
|
NFSERR_IO, /* ELIBEXEC = 87 */
|
|
NFSERR_IO, /* 88 */
|
|
NFSERR_IO, /* 89 */
|
|
NFSERR_IO, /* 90 */
|
|
NFSERR_IO, /* 91 */
|
|
NFSERR_IO, /* 92 */
|
|
NFSERR_IO, /* 93 */
|
|
NFSERR_IO, /* 94 */
|
|
NFSERR_IO, /* 95 */
|
|
NFSERR_IO, /* 96 */
|
|
NFSERR_IO, /* 97 */
|
|
NFSERR_IO, /* 98 */
|
|
NFSERR_IO, /* 99 */
|
|
NFSERR_IO, /* 100 */
|
|
NFSERR_IO, /* EWOULDBLOCK = 101 */
|
|
NFSERR_IO, /* EINPROGRESS = 102 */
|
|
NFSERR_IO, /* EALREADY = 103 */
|
|
NFSERR_IO, /* ENOTSOCK = 104 */
|
|
NFSERR_IO, /* EDESTADDRREQ = 105 */
|
|
NFSERR_IO, /* EMSGSIZE = 106 */
|
|
NFSERR_IO, /* EPROTOTYPE = 107 */
|
|
NFSERR_IO, /* ENOPROTOOPT = 108 */
|
|
NFSERR_IO, /* EPROTONOSUPPORT = 109 */
|
|
NFSERR_IO, /* ESOCKTNOSUPPORT = 110 */
|
|
NFSERR_IO, /* EOPNOTSUPP = 111 */
|
|
NFSERR_IO, /* EPFNOSUPPORT = 112 */
|
|
NFSERR_IO, /* EAFNOSUPPORT = 113 */
|
|
NFSERR_IO, /* EADDRINUSE = 114 */
|
|
NFSERR_IO, /* EADDRNOTAVAIL = 115 */
|
|
NFSERR_IO, /* ENETDOWN = 116 */
|
|
NFSERR_IO, /* ENETUNREACH = 117 */
|
|
NFSERR_IO, /* ENETRESET = 118 */
|
|
NFSERR_IO, /* ECONNABORTED = 119 */
|
|
NFSERR_IO, /* ECONNRESET = 120 */
|
|
NFSERR_IO, /* ENOBUFS = 121 */
|
|
NFSERR_IO, /* EISCONN = 122 */
|
|
NFSERR_IO, /* ENOTCONN = 123 */
|
|
NFSERR_IO, /* ESHUTDOWN = 124 */
|
|
NFSERR_IO, /* ETOOMANYREFS = 125 */
|
|
NFSERR_IO, /* ETIMEDOUT = 126 */
|
|
NFSERR_IO, /* ECONNREFUSED = 127 */
|
|
NFSERR_IO, /* EHOSTDOWN = 128 */
|
|
NFSERR_IO, /* EHOSTUNREACH = 129 */
|
|
NFSERR_IO, /* ELOOP = 130 */
|
|
NFSERR_NAMETOOLONG, /* ENAMETOOLONG = 131 */
|
|
NFSERR_NOTEMPTY, /* ENOTEMPTY = 132 */
|
|
NFSERR_DQUOT, /* EDQUOT = 133 */
|
|
NFSERR_STALE, /* ESTALE = 134 */
|
|
NFSERR_IO, /* ENFSREMOTE = 135 */
|
|
};
|
|
|
|
static struct dnode *
|
|
fhtodp(nfs_fh *nfh, nfsstat *status)
|
|
{
|
|
fhandle_t *fh;
|
|
struct dfs *dfs;
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
fh = (fhandle_t *) nfh;
|
|
dfs = dos_getfs(fh->fh_dev);
|
|
if (dfs == 0) {
|
|
*status = NFSERR_STALE;
|
|
return 0;
|
|
}
|
|
error = dos_getnode(dfs, fh->fh_fno, &dp);
|
|
if (error) {
|
|
*status = errno_to_nfsstat(error);
|
|
return 0;
|
|
}
|
|
return dp;
|
|
}
|
|
|
|
static void
|
|
makefh(struct dnode *dp, nfs_fh *nfh)
|
|
{
|
|
fhandle_t *fh;
|
|
|
|
fh = (fhandle_t *) nfh;
|
|
bzero(fh, sizeof *fh);
|
|
fh->fh_dev = dp->d_dfs->dfs_dev;
|
|
fh->fh_fid.lfid_len = sizeof fh->fh_fid - sizeof fh->fh_fid.lfid_len;
|
|
fh->fh_fid.lfid_fno = dp->d_fno;
|
|
}
|
|
|
|
static void
|
|
nfs_null()
|
|
{
|
|
}
|
|
|
|
static void
|
|
nfs_getattr(fh, as)
|
|
nfs_fh *fh;
|
|
attrstat *as;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(fh, &as->status);
|
|
if (dp == 0)
|
|
return;
|
|
error = dos_getattr(dp, &as->as_attributes);
|
|
if (error == 134){
|
|
printf(" Stale File Handle \n");
|
|
}
|
|
dos_putnode(dp);
|
|
as->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_setattr(sa, as)
|
|
sattrargs *sa;
|
|
attrstat *as;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(&sa->file, &as->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else {
|
|
error = dos_setattr(dp, &sa->attributes);
|
|
if (!error)
|
|
error = dos_getattr(dp, &as->as_attributes);
|
|
}
|
|
dos_putnode(dp);
|
|
as->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_lookup(da, dr)
|
|
diropargs *da;
|
|
diropres *dr;
|
|
{
|
|
struct dnode *dp;
|
|
struct dnode *cdp;
|
|
int error;
|
|
|
|
dp = fhtodp(&da->dir, &dr->status);
|
|
if (dp == 0)
|
|
return;
|
|
error = dos_lookup(dp, da->name, &cdp);
|
|
if (!error) {
|
|
error = dos_getattr(cdp, &dr->dr_attributes);
|
|
if (!error)
|
|
makefh(cdp, &dr->dr_file);
|
|
dos_putnode(cdp);
|
|
}
|
|
dos_putnode(dp);
|
|
dr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_readlink(fh, rlr)
|
|
nfs_fh *fh;
|
|
readlinkres *rlr;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(fh, &rlr->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_ftype != NFLNK)
|
|
error = ENXIO;
|
|
else {
|
|
rlr->rlr_data = safe_malloc(NFS_MAXPATHLEN);
|
|
error = dos_readlink(dp, NFS_MAXPATHLEN, rlr->rlr_data);
|
|
}
|
|
dos_putnode(dp);
|
|
rlr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
freereadlinkres(rlr)
|
|
readlinkres *rlr;
|
|
{
|
|
if (rlr->rlr_data)
|
|
free(rlr->rlr_data);
|
|
}
|
|
|
|
static void
|
|
nfs_read(ra, rr, rq)
|
|
readargs *ra;
|
|
readres *rr;
|
|
struct svc_req *rq;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(&ra->file, &rr->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_ftype != NFREG)
|
|
error = EISDIR;
|
|
else {
|
|
error = dos_access(dp, AUP(rq), AREAD);
|
|
if (!error) {
|
|
rr->rr_data.data_val = safe_malloc(ra->count);
|
|
error = dos_read(dp, ra->offset, ra->count,
|
|
rr->rr_data.data_val,
|
|
&rr->rr_data.data_len);
|
|
if (!error)
|
|
error = dos_getattr(dp, &rr->rr_attributes);
|
|
}
|
|
}
|
|
dos_putnode(dp);
|
|
rr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
freereadres(rr)
|
|
readres *rr;
|
|
{
|
|
if (rr->rr_data.data_val)
|
|
free(rr->rr_data.data_val);
|
|
}
|
|
|
|
static void
|
|
nfs_write(wa, as, rq)
|
|
writeargs *wa;
|
|
attrstat *as;
|
|
struct svc_req *rq;
|
|
{
|
|
struct dnode *dp;
|
|
int error=0;
|
|
|
|
dp = fhtodp(&wa->file, &as->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else if (dp->d_ftype != NFREG)
|
|
error = EISDIR;
|
|
else {
|
|
/* kludge to allow creator of readonly file to write */
|
|
if (AUP(rq)->aup_uid != dp->d_uid)
|
|
error = dos_access(dp, AUP(rq), AWRITE);
|
|
if (!error) {
|
|
error = dos_write(dp, wa->offset, wa->data.data_len,
|
|
wa->data.data_val);
|
|
if (!error)
|
|
error = dos_getattr(dp, &as->as_attributes);
|
|
}
|
|
}
|
|
dos_putnode(dp);
|
|
as->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_create(ca, dr, rq)
|
|
createargs *ca;
|
|
diropres *dr;
|
|
struct svc_req *rq;
|
|
{
|
|
struct dnode *dp;
|
|
struct dnode *cdp;
|
|
int error;
|
|
|
|
dp = fhtodp(&ca->where.dir, &dr->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else {
|
|
error = dos_create(dp, ca->where.name, &ca->attributes, &cdp, AUP(rq));
|
|
if (!error) {
|
|
error = dos_getattr(cdp, &dr->dr_attributes);
|
|
if (!error)
|
|
makefh(cdp, &dr->dr_file);
|
|
dos_putnode(cdp);
|
|
}
|
|
}
|
|
dos_putnode(dp);
|
|
dr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_remove(da, ns)
|
|
diropargs *da;
|
|
nfsstat *ns;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(&da->dir, ns);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else
|
|
error = dos_remove(dp, da->name);
|
|
dos_putnode(dp);
|
|
*ns = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_rename(rna, ns)
|
|
renameargs *rna;
|
|
nfsstat *ns;
|
|
{
|
|
struct dnode *dp, *tdp;
|
|
int error;
|
|
|
|
dp = fhtodp(&rna->from.dir, ns);
|
|
if (dp == 0)
|
|
return;
|
|
tdp = fhtodp(&rna->to.dir, ns);
|
|
if (tdp == 0) {
|
|
dos_putnode(dp);
|
|
return;
|
|
}
|
|
if ((dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
|| (tdp->d_dfs->dfs_flags & DFS_RDONLY)) {
|
|
error = EROFS;
|
|
} else
|
|
error = dos_rename(dp, rna->from.name, tdp, rna->to.name);
|
|
dos_putnode(dp);
|
|
dos_putnode(tdp);
|
|
*ns = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_link(la, ns)
|
|
linkargs *la;
|
|
nfsstat *ns;
|
|
{
|
|
struct dnode *dp, *tdp;
|
|
int error;
|
|
|
|
dp = fhtodp(&la->from, ns);
|
|
if (dp == 0)
|
|
return;
|
|
tdp = fhtodp(&la->to.dir, ns);
|
|
if (tdp == 0) {
|
|
dos_putnode(dp);
|
|
return;
|
|
}
|
|
if ((dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
|| (tdp->d_dfs->dfs_flags & DFS_RDONLY)) {
|
|
error = EROFS;
|
|
} else
|
|
error = dos_link(dp, tdp, la->to.name);
|
|
dos_putnode(dp);
|
|
dos_putnode(tdp);
|
|
*ns = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_symlink(sla, ns)
|
|
symlinkargs *sla;
|
|
nfsstat *ns;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(&sla->from.dir, ns);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else {
|
|
error = dos_symlink(dp, sla->from.name, &sla->attributes,
|
|
sla->to);
|
|
}
|
|
dos_putnode(dp);
|
|
*ns = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_mkdir(ca, dr, rq)
|
|
createargs *ca;
|
|
diropres *dr;
|
|
struct svc_req *rq;
|
|
{
|
|
struct dnode *dp;
|
|
struct dnode *cdp;
|
|
int error;
|
|
|
|
dp = fhtodp(&ca->where.dir, &dr->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else {
|
|
error = dos_mkdir(dp, ca->where.name, &ca->attributes, &cdp, AUP(rq));
|
|
if (!error) {
|
|
error = dos_getattr(cdp, &dr->dr_attributes);
|
|
if (!error)
|
|
makefh(cdp, &dr->dr_file);
|
|
dos_putnode(cdp);
|
|
}
|
|
}
|
|
dos_putnode(dp);
|
|
dr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_rmdir(da, ns)
|
|
diropargs *da;
|
|
nfsstat *ns;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(&da->dir, ns);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_dfs->dfs_flags & DFS_RDONLY)
|
|
error = EROFS;
|
|
else
|
|
error = dos_rmdir(dp, da->name);
|
|
dos_putnode(dp);
|
|
*ns = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
nfs_readdir(rda, rdr, rq)
|
|
readdirargs *rda;
|
|
readdirres *rdr;
|
|
struct svc_req *rq;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
u_int nread;
|
|
|
|
dp = fhtodp(&rda->dir, &rdr->status);
|
|
if (dp == 0)
|
|
return;
|
|
if (dp->d_ftype != NFDIR)
|
|
error = ENOTDIR;
|
|
else {
|
|
error = dos_access(dp, AUP(rq), AREAD);
|
|
if (!error) {
|
|
rdr->rdr_entries = (entry *) safe_malloc(rda->count);
|
|
error = dos_readdir(dp, rda->cookie, rda->count,
|
|
rdr->rdr_entries, &rdr->rdr_eof, &nread);
|
|
if (nread == 0) {
|
|
free(rdr->rdr_entries);
|
|
rdr->rdr_entries = 0;
|
|
}
|
|
}
|
|
}
|
|
dos_putnode(dp);
|
|
rdr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static void
|
|
freereaddirres(rdr)
|
|
readdirres *rdr;
|
|
{
|
|
if (rdr->rdr_entries)
|
|
free(rdr->rdr_entries);
|
|
}
|
|
|
|
static void
|
|
nfs_statfs(fh, sfr)
|
|
nfs_fh *fh;
|
|
statfsres *sfr;
|
|
{
|
|
struct dnode *dp;
|
|
int error;
|
|
|
|
dp = fhtodp(fh, &sfr->status);
|
|
if (dp == 0)
|
|
return;
|
|
sfr->sfr_reply.tsize = NFS_MAXDATA;
|
|
error = dos_statfs(dp->d_dfs, &sfr->sfr_reply);
|
|
dos_putnode(dp);
|
|
sfr->status = errno_to_nfsstat(error);
|
|
}
|
|
|
|
static struct dispatch {
|
|
char *name;
|
|
void (*proc)();
|
|
unsigned argsize;
|
|
xdrproc_t xdrargs;
|
|
unsigned resultsize;
|
|
xdrproc_t xdrresults;
|
|
void (*freeres)();
|
|
} dispatch[] = {
|
|
{ "NULL", nfs_null,
|
|
0, xdr_void, 0, xdr_void, 0 },
|
|
{ "GETATTR", nfs_getattr,
|
|
sizeof(nfs_fh), xdr_nfs_fh,
|
|
sizeof(attrstat), xdr_attrstat, 0 },
|
|
{ "SETATTR", nfs_setattr,
|
|
sizeof(sattrargs), xdr_sattrargs,
|
|
sizeof(attrstat), xdr_attrstat, 0 },
|
|
{ "ROOT", nfs_null,
|
|
0, xdr_void, 0, xdr_void, 0 },
|
|
{ "LOOKUP", nfs_lookup,
|
|
sizeof(diropargs), xdr_diropargs,
|
|
sizeof(diropres), xdr_diropres, 0 },
|
|
{ "READLINK", nfs_readlink,
|
|
sizeof(nfs_fh), xdr_nfs_fh,
|
|
sizeof(readlinkres), xdr_readlinkres,
|
|
freereadlinkres },
|
|
{ "READ", nfs_read,
|
|
sizeof(readargs), xdr_readargs,
|
|
sizeof(readres), xdr_readres,
|
|
freereadres },
|
|
{ "WRITECACHE", nfs_null,
|
|
0, xdr_void, 0, xdr_void, 0 },
|
|
{ "WRITE", nfs_write,
|
|
sizeof(writeargs), xdr_writeargs,
|
|
sizeof(attrstat), xdr_attrstat, 0 },
|
|
{ "CREATE", nfs_create,
|
|
sizeof(createargs), xdr_createargs,
|
|
sizeof(diropres), xdr_diropres, 0 },
|
|
{ "REMOVE", nfs_remove,
|
|
sizeof(diropargs), xdr_diropargs,
|
|
sizeof(nfsstat), xdr_nfsstat, 0 },
|
|
{ "RENAME", nfs_rename,
|
|
sizeof(renameargs), xdr_renameargs,
|
|
sizeof(nfsstat), xdr_nfsstat, 0 },
|
|
{ "LINK", nfs_link,
|
|
sizeof(linkargs), xdr_linkargs,
|
|
sizeof(nfsstat), xdr_nfsstat, 0 },
|
|
{ "SYMLINK", nfs_symlink,
|
|
sizeof(symlinkargs), xdr_symlinkargs,
|
|
sizeof(nfsstat), xdr_nfsstat, 0 },
|
|
{ "MKDIR", nfs_mkdir,
|
|
sizeof(createargs), xdr_createargs,
|
|
sizeof(diropres), xdr_diropres, 0 },
|
|
{ "RMDIR", nfs_rmdir,
|
|
sizeof(diropargs), xdr_diropargs,
|
|
sizeof(nfsstat), xdr_nfsstat, 0 },
|
|
{ "READDIR", nfs_readdir,
|
|
sizeof(readdirargs), xdr_readdirargs,
|
|
sizeof(readdirres), xdr_readdirres,
|
|
freereaddirres },
|
|
{ "STATFS", nfs_statfs,
|
|
sizeof(nfs_fh), xdr_nfs_fh,
|
|
sizeof(statfsres), xdr_statfsres, 0 }
|
|
};
|
|
|
|
union nfsargs {
|
|
nfs_fh nfs_fh;
|
|
sattrargs sattrargs;
|
|
diropargs diropargs;
|
|
readargs readargs;
|
|
writeargs writeargs;
|
|
createargs createargs;
|
|
renameargs renameargs;
|
|
linkargs linkargs;
|
|
readdirargs readdirargs;
|
|
};
|
|
|
|
union nfsresults {
|
|
attrstat attrstat;
|
|
diropres diropres;
|
|
readlinkres readlinkres;
|
|
readres readres;
|
|
nfsstat nfsstat;
|
|
readdirres readdirres;
|
|
statfsres statfsres;
|
|
};
|
|
|
|
void
|
|
nfs_service(rq, transp)
|
|
struct svc_req *rq;
|
|
SVCXPRT *transp;
|
|
{
|
|
u_long which;
|
|
struct dispatch *disp;
|
|
char args[sizeof(union nfsargs)];
|
|
char results[sizeof(union nfsresults)];
|
|
|
|
which = rq->rq_proc;
|
|
if (which >= sizeof dispatch / sizeof dispatch[0]) {
|
|
svcerr_noproc(transp);
|
|
return;
|
|
}
|
|
disp = &dispatch[which];
|
|
|
|
bzero(args, disp->argsize);
|
|
if (!svc_getargs(transp, disp->xdrargs, args)) {
|
|
svcerr_decode(transp);
|
|
return;
|
|
}
|
|
|
|
if (which != NFSPROC_NULL) {
|
|
if (rq->rq_cred.oa_flavor != AUTH_UNIX) {
|
|
svcerr_weakauth(transp);
|
|
return;
|
|
}
|
|
/* authenticate ? */
|
|
}
|
|
|
|
trace("calling %s\n", disp->name);
|
|
bzero(results, disp->resultsize);
|
|
(*disp->proc)(args, results, rq);
|
|
if (!svc_sendreply(transp, disp->xdrresults, results))
|
|
svcerr_systemerr(transp);
|
|
if (!svc_freeargs(transp, disp->xdrargs, args)) {
|
|
syslog(LOG_ERR, "can't free %s arguments", disp->name);
|
|
terminate(1);
|
|
}
|
|
if (disp->freeres)
|
|
(*disp->freeres)(results);
|
|
}
|