root/lib/libsa/nfs.c

DEFINITIONS

1. nfs_getrootfh
2. nfs_lookupfh
3. nfs_readlink
4. nfs_readdata
5. nfs_mount
6. nfs_open
7. nfs_close
8. nfs_read
9. nfs_write
10. nfs_seek
11. nfs_stat
12. nfs_readdir

    1 /*      $OpenBSD: nfs.c,v 1.10 2003/08/11 06:23:09 deraadt Exp $        */
    2 /*      $NetBSD: nfs.c,v 1.19 1996/10/13 02:29:04 christos Exp $        */
    4 /*-
    5  *  Copyright (c) 1993 John Brezak
    6  *  All rights reserved.
    7  *
    8  *  Redistribution and use in source and binary forms, with or without
    9  *  modification, are permitted provided that the following conditions
   10  *  are met:
   11  *  1. Redistributions of source code must retain the above copyright
   12  *     notice, this list of conditions and the following disclaimer.
   13  *  2. Redistributions in binary form must reproduce the above copyright
   14  *     notice, this list of conditions and the following disclaimer in the
   15  *     documentation and/or other materials provided with the distribution.
   16  *  3. The name of the author may not be used to endorse or promote products
   17  *     derived from this software without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
   20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   22  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   25  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   27  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   29  * POSSIBILITY OF SUCH DAMAGE.
   30  */
   32 #include <sys/param.h>
   33 #include <sys/time.h>
   34 #include <sys/socket.h>
   35 #include <sys/stat.h>
   37 #include <netinet/in.h>
   38 #include <netinet/in_systm.h>
   40 #include "rpcv2.h"
   41 #include "nfsv2.h"
   43 #include "stand.h"
   44 #include "saerrno.h"
   45 #include "net.h"
   46 #include "netif.h"
   47 #include "nfs.h"
   48 #include "rpc.h"
   50 /* Define our own NFS attributes without NQNFS stuff. */
   51 struct nfsv2_fattrs {
n_long  fa_type;
n_long  fa_mode;
n_long  fa_nlink;
n_long  fa_uid;
n_long  fa_gid;
n_long  fa_size;
n_long  fa_blocksize;
n_long  fa_rdev;
n_long  fa_blocks;
n_long  fa_fsid;
n_long  fa_fileid;
   63         struct nfsv2_time fa_atime;
   64         struct nfsv2_time fa_mtime;
   65         struct nfsv2_time fa_ctime;
   66 };
   69 struct nfs_read_args {
u_char  fh[NFS_FHSIZE];
n_long  off;
n_long  len;
n_long  xxx;                    /* XXX what's this for? */
   74 };
   76 /* Data part of nfs rpc reply (also the largest thing we receive) */
   77 #define NFSREAD_SIZE 1024
   78 struct nfs_read_repl {
n_long  errno;
   80         struct  nfsv2_fattrs fa;
n_long  count;
u_char  data[NFSREAD_SIZE];
   83 };
   85 struct nfs_readlnk_repl {
n_long  errno;
n_long  len;
   88         char    path[NFS_MAXPATHLEN];
   89 };
   91 struct nfs_iodesc {
   92         struct  iodesc  *iodesc;
off_t   off;
u_char  fh[NFS_FHSIZE];
   95         struct nfsv2_fattrs fa; /* all in network order */
   96 };
   98 struct nfs_iodesc nfs_root_node;
  101 /*
  102  * Fetch the root file handle (call mount daemon)
  103  * On error, return non-zero and set errno.
  104  */
  105 static int
nfs_getrootfh(struct iodesc *d, char *path, u_char *fhp)
  107 {
  108         int len;
  109         struct args {
n_long  len;
  111                 char    path[FNAME_SIZE];
  112         } *args;
  113         struct repl {
n_long  errno;
u_char  fh[NFS_FHSIZE];
  116         } *repl;
  117         struct {
n_long  h[RPC_HEADER_WORDS];
  119                 struct args d;
  120         } sdata;
  121         struct {
n_long  h[RPC_HEADER_WORDS];
  123                 struct repl d;
  124         } rdata;
size_t cc;
  127 #ifdef NFS_DEBUG
  128         if (debug)
printf("nfs_getrootfh: %s\n", path);
  130 #endif
args = &sdata.d;
repl = &rdata.d;
bzero(args, sizeof(*args));
len = strlen(path);
  137         if (len > sizeof(args->path))
len = sizeof(args->path);
args->len = htonl(len);
bcopy(path, args->path, len);
len = 4 + roundup(len, 4);
cc = rpc_call(d, RPCPROG_MNT, RPCMNT_VER1, RPCMNT_MOUNT,
args, len, repl, sizeof(*repl));
  145         if (cc == -1) {
  146                 /* errno was set by rpc_call */
  147                 return (-1);
  148         }
  149         if (cc < 4) {
errno = EBADRPC;
  151                 return (-1);
  152         }
  153         if (repl->errno) {
errno = ntohl(repl->errno);
  155                 return (-1);
  156         }
bcopy(repl->fh, fhp, sizeof(repl->fh));
  158         return (0);
  159 }
  161 /*
  162  * Lookup a file.  Store handle and attributes.
  163  * Return zero or error number.
  164  */
  165 static int
nfs_lookupfh(struct nfs_iodesc *d, char *name, struct nfs_iodesc *newfd)
  167 {
  168         int len, rlen;
  169         struct args {
u_char  fh[NFS_FHSIZE];
n_long  len;
  172                 char    name[FNAME_SIZE];
  173         } *args;
  174         struct repl {
n_long  errno;
u_char  fh[NFS_FHSIZE];
  177                 struct  nfsv2_fattrs fa;
  178         } *repl;
  179         struct {
n_long  h[RPC_HEADER_WORDS];
  181                 struct args d;
  182         } sdata;
  183         struct {
n_long  h[RPC_HEADER_WORDS];
  185                 struct repl d;
  186         } rdata;
ssize_t cc;
  189 #ifdef NFS_DEBUG
  190         if (debug)
printf("lookupfh: called\n");
  192 #endif
args = &sdata.d;
repl = &rdata.d;
bzero(args, sizeof(*args));
bcopy(d->fh, args->fh, sizeof(args->fh));
len = strlen(name);
  200         if (len > sizeof(args->name))
len = sizeof(args->name);
bcopy(name, args->name, len);
args->len = htonl(len);
len = 4 + roundup(len, 4);
len += NFS_FHSIZE;
rlen = sizeof(*repl);
cc = rpc_call(d->iodesc, NFS_PROG, NFS_VER2, NFSPROC_LOOKUP,
args, len, repl, rlen);
  211         if (cc == -1)
  212                 return (errno);         /* XXX - from rpc_call */
  213         if (cc < 4)
  214                 return (EIO);
  215         if (repl->errno) {
  216                 /* saerrno.h now matches NFS error numbers. */
  217                 return (ntohl(repl->errno));
  218         }
bcopy( repl->fh, &newfd->fh, sizeof(newfd->fh));
bcopy(&repl->fa, &newfd->fa, sizeof(newfd->fa));
  221         return (0);
  222 }
  224 /*
  225  * Get the destination of a symbolic link.
  226  */
  227 static int
nfs_readlink(struct nfs_iodesc *d, char *buf)
  229 {
  230         struct {
n_long  h[RPC_HEADER_WORDS];
u_char fh[NFS_FHSIZE];
  233         } sdata;
  234         struct {
n_long  h[RPC_HEADER_WORDS];
  236                 struct nfs_readlnk_repl d;
  237         } rdata;
ssize_t cc;
  240 #ifdef NFS_DEBUG
  241         if (debug)
printf("readlink: called\n");
  243 #endif
bcopy(d->fh, sdata.fh, NFS_FHSIZE);
cc = rpc_call(d->iodesc, NFS_PROG, NFS_VER2, NFSPROC_READLINK,
sdata.fh, NFS_FHSIZE,
  248             &rdata.d, sizeof(rdata.d));
  249         if (cc == -1)
  250                 return (errno);
  252         if (cc < 4)
  253                 return (EIO);
  255         if (rdata.d.errno)
  256                 return (ntohl(rdata.d.errno));
rdata.d.len = ntohl(rdata.d.len);
  259         if (rdata.d.len > NFS_MAXPATHLEN)
  260                 return (ENAMETOOLONG);
bcopy(rdata.d.path, buf, rdata.d.len);
buf[rdata.d.len] = 0;
  264         return (0);
  265 }
  267 /*
  268  * Read data from a file.
  269  * Return transfer count or -1 (and set errno)
  270  */
  271 static ssize_t
nfs_readdata(struct nfs_iodesc *d, off_t off, void *addr, size_t len)
  273 {
  274         struct nfs_read_args *args;
  275         struct nfs_read_repl *repl;
  276         struct {
n_long  h[RPC_HEADER_WORDS];
  278                 struct nfs_read_args d;
  279         } sdata;
  280         struct {
n_long  h[RPC_HEADER_WORDS];
  282                 struct nfs_read_repl d;
  283         } rdata;
size_t cc;
  285         long x;
  286         int hlen, rlen;
args = &sdata.d;
repl = &rdata.d;
bcopy(d->fh, args->fh, NFS_FHSIZE);
args->off = htonl((n_long)off);
  293         if (len > NFSREAD_SIZE)
len = NFSREAD_SIZE;
args->len = htonl((n_long)len);
args->xxx = htonl((n_long)0);
hlen = sizeof(*repl) - NFSREAD_SIZE;
cc = rpc_call(d->iodesc, NFS_PROG, NFS_VER2, NFSPROC_READ,
args, sizeof(*args),
repl, sizeof(*repl));
  302         if (cc == -1) {
  303                 /* errno was already set by rpc_call */
  304                 return (-1);
  305         }
  306         if (cc < hlen) {
errno = EBADRPC;
  308                 return (-1);
  309         }
  310         if (repl->errno) {
errno = ntohl(repl->errno);
  312                 return (-1);
  313         }
rlen = cc - hlen;
x = ntohl(repl->count);
  316         if (rlen < x) {
printf("nfsread: short packet, %d < %ld\n", rlen, x);
errno = EBADRPC;
  319                 return(-1);
  320         }
bcopy(repl->data, addr, x);
  322         return (x);
  323 }
  325 /*
  326  * nfs_mount - mount this nfs filesystem to a host
  327  * On error, return non-zero and set errno.
  328  */
  329 int
nfs_mount(int sock, struct in_addr ip, char *path)
  331 {
  332         struct iodesc *desc;
  333         struct nfsv2_fattrs *fa;
  335         if (!(desc = socktodesc(sock))) {
errno = EINVAL;
  337                 return(-1);
  338         }
  340         /* Bind to a reserved port. */
desc->myport = htons(--rpc_port);
desc->destip = ip;
  343         if (nfs_getrootfh(desc, path, nfs_root_node.fh))
  344                 return (-1);
nfs_root_node.iodesc = desc;
  346         /* Fake up attributes for the root dir. */
fa = &nfs_root_node.fa;
fa->fa_type  = htonl(NFDIR);
fa->fa_mode  = htonl(0755);
fa->fa_nlink = htonl(2);
  352 #ifdef NFS_DEBUG
  353         if (debug)
printf("nfs_mount: got fh for %s\n", path);
  355 #endif
  357         return(0);
  358 }
  360 /*
  361  * Open a file.
  362  * return zero or error number
  363  */
  364 int
nfs_open(char *path, struct open_file *f)
  366 {
  367         struct nfs_iodesc *newfd, *currfd;
  368         char namebuf[NFS_MAXPATHLEN + 1], *cp, *ncp;
  369         char linkbuf[NFS_MAXPATHLEN + 1];
  370         int nlinks = 0, error = 0, c;
  372 #ifdef NFS_DEBUG
  373         if (debug)
printf("nfs_open: %s\n", path);
  375 #endif
  376         if (nfs_root_node.iodesc == NULL) {
printf("nfs_open: must mount first.\n");
  378                 return (ENXIO);
  379         }
currfd = &nfs_root_node;
newfd = 0;
cp = path;
  385         while (*cp) {
  386                 /*
  387                  * Remove extra separators
  388                  */
  389                 while (*cp == '/')
cp++;
  392                 if (*cp == '\0')
  393                         break;
  394                 /*
  395                  * Check that current node is a directory.
  396                  */
  397                 if (currfd->fa.fa_type != htonl(NFDIR)) {
error = ENOTDIR;
  399                         goto out;
  400                 }
  402                 /* allocate file system specific data structure */
newfd = alloc(sizeof(*newfd));
newfd->iodesc = currfd->iodesc;
newfd->off = 0;
  407                 /*
  408                  * Get next component of path name.
  409                  */
  410                 {
  411                         int len = 0;
ncp = cp;
  414                         while ((c = *cp) != '\0' && c != '/') {
  415                                 if (++len > NFS_MAXNAMLEN) {
error = ENOENT;
  417                                         goto out;
  418                                 }
cp++;
  420                         }
  421                         *cp = '\0';
  422                 }
  424                 /* lookup a file handle */
error = nfs_lookupfh(currfd, ncp, newfd);
  426                 *cp = c;
  427                 if (error)
  428                         goto out;
  430                 /*
  431                  * Check for symbolic link
  432                  */
  433                 if (newfd->fa.fa_type == htonl(NFLNK)) {
  434                         int link_len, len;
error = nfs_readlink(newfd, linkbuf);
  437                         if (error)
  438                                 goto out;
link_len = strlen(linkbuf);
len = strlen(cp);
  443                         if (link_len + len > MAXPATHLEN ||
  444                             ++nlinks > MAXSYMLINKS) {
error = ENOENT;
  446                                 goto out;
  447                         }
bcopy(cp, &namebuf[link_len], len + 1);
bcopy(linkbuf, namebuf, link_len);
  452                         /*
  453                          * If absolute pathname, restart at root.
  454                          * If relative pathname, restart at parent directory.
  455                          */
cp = namebuf;
  457                         if (*cp == '/') {
  458                                 if (currfd != &nfs_root_node)
free(currfd, sizeof(*currfd));
currfd = &nfs_root_node;
  461                         }
free(newfd, sizeof(*newfd));
newfd = 0;
  466                         continue;
  467                 }
  469                 if (currfd != &nfs_root_node)
free(currfd, sizeof(*currfd));
currfd = newfd;
newfd = 0;
  473         }
error = 0;
out:
  478         if (!error) {
f->f_fsdata = (void *)currfd;
  480                 return (0);
  481         }
  483 #ifdef NFS_DEBUG
  484         if (debug)
printf("nfs_open: %s lookupfh failed: %s\n",
path, strerror(error));
  487 #endif
  488         if (currfd != &nfs_root_node)
free(currfd, sizeof(*currfd));
  490         if (newfd)
free(newfd, sizeof(*newfd));
  493         return (error);
  494 }
  496 int
nfs_close(struct open_file *f)
  498 {
  499         struct nfs_iodesc *fp = (struct nfs_iodesc *)f->f_fsdata;
  501 #ifdef NFS_DEBUG
  502         if (debug)
printf("nfs_close: fp=%p\n", fp);
  504 #endif
  506         if (fp)
free(fp, sizeof(struct nfs_iodesc));
f->f_fsdata = (void *)0;
  510         return (0);
  511 }
  513 /*
  514  * read a portion of a file
  515  */
  516 int
nfs_read(struct open_file *f, void *buf, size_t size, size_t *resid)
  518 {
  519         struct nfs_iodesc *fp = (struct nfs_iodesc *)f->f_fsdata;
ssize_t cc;
  521         char *addr = buf;
  523 #ifdef NFS_DEBUG
  524         if (debug)
printf("nfs_read: size=%d off=%d\n", size, (int)fp->off);
  526 #endif
  527         while ((int)size > 0) {
twiddle();
cc = nfs_readdata(fp, fp->off, (void *)addr, size);
  530                 /* XXX maybe should retry on certain errors */
  531                 if (cc == -1) {
  532 #ifdef NFS_DEBUG
  533                         if (debug)
printf("nfs_read: read: %s", strerror(errno));
  535 #endif
  536                         return (errno); /* XXX - from nfs_readdata */
  537                 }
  538                 if (cc == 0) {
  539                         if (debug)
printf("nfs_read: hit EOF unexpectantly");
  541                         goto ret;
  542                 }
fp->off += cc;
addr += cc;
size -= cc;
  546         }
ret:
  548         if (resid)
  549                 *resid = size;
  551         return (0);
  552 }
  554 /*
  555  * Not implemented.
  556  */
  557 int
nfs_write(struct open_file *f, void *buf, size_t size, size_t *resid)
  559 {
  560         return (EROFS);
  561 }
off_t
nfs_seek(struct open_file *f, off_t offset, int where)
  565 {
  566         struct nfs_iodesc *d = (struct nfs_iodesc *)f->f_fsdata;
n_long size = ntohl(d->fa.fa_size);
  569         switch (where) {
  570         case SEEK_SET:
d->off = offset;
  572                 break;
  573         case SEEK_CUR:
d->off += offset;
  575                 break;
  576         case SEEK_END:
d->off = size - offset;
  578                 break;
  579         default:
  580                 return (-1);
  581         }
  583         return (d->off);
  584 }
  586 /* NFNON=0, NFREG=1, NFDIR=2, NFBLK=3, NFCHR=4, NFLNK=5 */
  587 int nfs_stat_types[8] = {
  588         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, 0 };
  590 int
nfs_stat(struct open_file *f, struct stat *sb)
  592 {
  593         struct nfs_iodesc *fp = (struct nfs_iodesc *)f->f_fsdata;
n_long ftype, mode;
ftype = ntohl(fp->fa.fa_type);
mode  = ntohl(fp->fa.fa_mode);
mode |= nfs_stat_types[ftype & 7];
sb->st_mode  = mode;
sb->st_nlink = ntohl(fp->fa.fa_nlink);
sb->st_uid   = ntohl(fp->fa.fa_uid);
sb->st_gid   = ntohl(fp->fa.fa_gid);
sb->st_size  = ntohl(fp->fa.fa_size);
  606         return (0);
  607 }
  609 /*
  610  * Not implemented.
  611  */
  612 #ifndef NO_READDIR
  613 int
nfs_readdir(struct open_file *f, char *name)
  615 {
  616         return (EROFS);
  617 }
  618 #endif