1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * %sccs.include.redist.c% 9 * 10 * @(#)nfs_serv.c 7.65 (Berkeley) 05/21/93 11 */ 12 13 /* 14 * nfs version 2 server calls to vnode ops 15 * - these routines generally have 3 phases 16 * 1 - break down and validate rpc request in mbuf list 17 * 2 - do the vnode ops for the request 18 * (surprisingly ?? many are very similar to syscalls in vfs_syscalls.c) 19 * 3 - build the rpc reply in an mbuf list 20 * nb: 21 * - do not mix the phases, since the nfsm_?? macros can return failures 22 * on a bad rpc or similar and do not do any vrele() or vput()'s 23 * 24 * - the nfsm_reply() macro generates an nfs rpc reply with the nfs 25 * error number iff error != 0 whereas 26 * returning an error from the server function implies a fatal error 27 * such as a badly constructed rpc request that should be dropped without 28 * a reply. 29 */ 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/proc.h> 34 #include <sys/file.h> 35 #include <sys/namei.h> 36 #include <sys/vnode.h> 37 #include <sys/mount.h> 38 #include <sys/mbuf.h> 39 #include <sys/dirent.h> 40 #include <sys/stat.h> 41 42 #include <vm/vm.h> 43 44 #include <nfs/nfsv2.h> 45 #include <nfs/rpcv2.h> 46 #include <nfs/nfs.h> 47 #include <nfs/xdr_subs.h> 48 #include <nfs/nfsm_subs.h> 49 #include <nfs/nqnfs.h> 50 51 /* Defs */ 52 #define TRUE 1 53 #define FALSE 0 54 55 /* Global vars */ 56 extern u_long nfs_procids[NFS_NPROCS]; 57 extern u_long nfs_xdrneg1; 58 extern u_long nfs_false, nfs_true; 59 nfstype nfs_type[9] = { NFNON, NFREG, NFDIR, NFBLK, NFCHR, NFLNK, NFNON, 60 NFCHR, NFNON }; 61 62 /* 63 * nqnfs access service 64 */ 65 nqnfsrv_access(nfsd, mrep, md, dpos, cred, nam, mrq) 66 struct nfsd *nfsd; 67 struct mbuf *mrep, *md; 68 caddr_t dpos; 69 struct ucred *cred; 70 struct mbuf *nam, **mrq; 71 { 72 struct vnode *vp; 73 nfsv2fh_t nfh; 74 fhandle_t *fhp; 75 register u_long *tl; 76 register long t1; 77 caddr_t bpos; 78 int error = 0, rdonly, cache, mode = 0; 79 char *cp2; 80 struct mbuf *mb, *mb2, *mreq; 81 u_quad_t frev; 82 83 fhp = &nfh.fh_generic; 84 nfsm_srvmtofh(fhp); 85 nfsm_dissect(tl, u_long *, 3 * NFSX_UNSIGNED); 86 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 87 nfsm_reply(0); 88 if (*tl++ == nfs_true) 89 mode |= VREAD; 90 if (*tl++ == nfs_true) 91 mode |= VWRITE; 92 if (*tl == nfs_true) 93 mode |= VEXEC; 94 error = nfsrv_access(vp, mode, cred, rdonly, nfsd->nd_procp); 95 vput(vp); 96 nfsm_reply(0); 97 nfsm_srvdone; 98 } 99 100 /* 101 * nfs getattr service 102 */ 103 nfsrv_getattr(nfsd, mrep, md, dpos, cred, nam, mrq) 104 struct nfsd *nfsd; 105 struct mbuf *mrep, *md; 106 caddr_t dpos; 107 struct ucred *cred; 108 struct mbuf *nam, **mrq; 109 { 110 register struct nfsv2_fattr *fp; 111 struct vattr va; 112 register struct vattr *vap = &va; 113 struct vnode *vp; 114 nfsv2fh_t nfh; 115 fhandle_t *fhp; 116 register u_long *tl; 117 register long t1; 118 caddr_t bpos; 119 int error = 0, rdonly, cache; 120 char *cp2; 121 struct mbuf *mb, *mb2, *mreq; 122 u_quad_t frev; 123 124 fhp = &nfh.fh_generic; 125 nfsm_srvmtofh(fhp); 126 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 127 nfsm_reply(0); 128 nqsrv_getl(vp, NQL_READ); 129 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 130 vput(vp); 131 nfsm_reply(NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 132 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 133 nfsm_srvfillattr; 134 nfsm_srvdone; 135 } 136 137 /* 138 * nfs setattr service 139 */ 140 nfsrv_setattr(nfsd, mrep, md, dpos, cred, nam, mrq) 141 struct nfsd *nfsd; 142 struct mbuf *mrep, *md; 143 caddr_t dpos; 144 struct ucred *cred; 145 struct mbuf *nam, **mrq; 146 { 147 struct vattr va; 148 register struct vattr *vap = &va; 149 register struct nfsv2_sattr *sp; 150 register struct nfsv2_fattr *fp; 151 struct vnode *vp; 152 nfsv2fh_t nfh; 153 fhandle_t *fhp; 154 register u_long *tl; 155 register long t1; 156 caddr_t bpos; 157 int error = 0, rdonly, cache, duration2, cache2; 158 char *cp2; 159 struct mbuf *mb, *mb2, *mreq; 160 u_quad_t frev, frev2; 161 162 fhp = &nfh.fh_generic; 163 nfsm_srvmtofh(fhp); 164 nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_SATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 165 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 166 nfsm_reply(0); 167 nqsrv_getl(vp, NQL_WRITE); 168 VATTR_NULL(vap); 169 /* 170 * Nah nah nah nah na nah 171 * There is a bug in the Sun client that puts 0xffff in the mode 172 * field of sattr when it should put in 0xffffffff. The u_short 173 * doesn't sign extend. 174 * --> check the low order 2 bytes for 0xffff 175 */ 176 if ((fxdr_unsigned(int, sp->sa_mode) & 0xffff) != 0xffff) 177 vap->va_mode = nfstov_mode(sp->sa_mode); 178 if (sp->sa_uid != nfs_xdrneg1) 179 vap->va_uid = fxdr_unsigned(uid_t, sp->sa_uid); 180 if (sp->sa_gid != nfs_xdrneg1) 181 vap->va_gid = fxdr_unsigned(gid_t, sp->sa_gid); 182 if (nfsd->nd_nqlflag == NQL_NOVAL) { 183 if (sp->sa_nfssize != nfs_xdrneg1) 184 vap->va_size = fxdr_unsigned(u_quad_t, sp->sa_nfssize); 185 if (sp->sa_nfsatime.nfs_sec != nfs_xdrneg1) { 186 #ifdef notyet 187 fxdr_nfstime(&sp->sa_nfsatime, &vap->va_atime); 188 #else 189 vap->va_atime.ts_sec = 190 fxdr_unsigned(long, sp->sa_nfsatime.nfs_sec); 191 vap->va_atime.ts_nsec = 0; 192 #endif 193 } 194 if (sp->sa_nfsmtime.nfs_sec != nfs_xdrneg1) 195 fxdr_nfstime(&sp->sa_nfsmtime, &vap->va_mtime); 196 } else { 197 fxdr_hyper(&sp->sa_nqsize, &vap->va_size); 198 fxdr_nqtime(&sp->sa_nqatime, &vap->va_atime); 199 fxdr_nqtime(&sp->sa_nqmtime, &vap->va_mtime); 200 vap->va_flags = fxdr_unsigned(u_long, sp->sa_nqflags); 201 } 202 203 /* 204 * If the size is being changed write acces is required, otherwise 205 * just check for a read only file system. 206 */ 207 if (vap->va_size == ((u_quad_t)((quad_t) -1))) { 208 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) { 209 error = EROFS; 210 goto out; 211 } 212 } else { 213 if (vp->v_type == VDIR) { 214 error = EISDIR; 215 goto out; 216 } else if (error = nfsrv_access(vp, VWRITE, cred, rdonly, 217 nfsd->nd_procp)) 218 goto out; 219 } 220 if (error = VOP_SETATTR(vp, vap, cred, nfsd->nd_procp)) { 221 vput(vp); 222 nfsm_reply(0); 223 } 224 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 225 out: 226 vput(vp); 227 nfsm_reply(NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL) + 2*NFSX_UNSIGNED); 228 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 229 nfsm_srvfillattr; 230 if (nfsd->nd_nqlflag != NQL_NOVAL) { 231 nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED); 232 txdr_hyper(&frev2, tl); 233 } 234 nfsm_srvdone; 235 } 236 237 /* 238 * nfs lookup rpc 239 */ 240 nfsrv_lookup(nfsd, mrep, md, dpos, cred, nam, mrq) 241 struct nfsd *nfsd; 242 struct mbuf *mrep, *md; 243 caddr_t dpos; 244 struct ucred *cred; 245 struct mbuf *nam, **mrq; 246 { 247 register struct nfsv2_fattr *fp; 248 struct nameidata nd; 249 struct vnode *vp; 250 nfsv2fh_t nfh; 251 fhandle_t *fhp; 252 register caddr_t cp; 253 register u_long *tl; 254 register long t1; 255 caddr_t bpos; 256 int error = 0, rdonly, cache, duration2, cache2, len; 257 char *cp2; 258 struct mbuf *mb, *mb2, *mreq; 259 struct vattr va, *vap = &va; 260 u_quad_t frev, frev2; 261 262 fhp = &nfh.fh_generic; 263 duration2 = 0; 264 if (nfsd->nd_nqlflag != NQL_NOVAL) { 265 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED); 266 duration2 = fxdr_unsigned(int, *tl); 267 } 268 nfsm_srvmtofh(fhp); 269 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 270 nd.ni_cnd.cn_cred = cred; 271 nd.ni_cnd.cn_nameiop = LOOKUP; 272 nd.ni_cnd.cn_flags = LOCKLEAF | SAVESTART; 273 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 274 nfsd->nd_procp)) 275 nfsm_reply(0); 276 nqsrv_getl(nd.ni_startdir, NQL_READ); 277 vrele(nd.ni_startdir); 278 FREE(nd.ni_cnd.cn_pnbuf, M_NAMEI); 279 vp = nd.ni_vp; 280 bzero((caddr_t)fhp, sizeof(nfh)); 281 fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; 282 if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) { 283 vput(vp); 284 nfsm_reply(0); 285 } 286 if (duration2) 287 (void) nqsrv_getlease(vp, &duration2, NQL_READ, nfsd, 288 nam, &cache2, &frev2, cred); 289 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 290 vput(vp); 291 nfsm_reply(NFSX_FH + NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL) + 5*NFSX_UNSIGNED); 292 if (nfsd->nd_nqlflag != NQL_NOVAL) { 293 if (duration2) { 294 nfsm_build(tl, u_long *, 5*NFSX_UNSIGNED); 295 *tl++ = txdr_unsigned(NQL_READ); 296 *tl++ = txdr_unsigned(cache2); 297 *tl++ = txdr_unsigned(duration2); 298 txdr_hyper(&frev2, tl); 299 } else { 300 nfsm_build(tl, u_long *, NFSX_UNSIGNED); 301 *tl = 0; 302 } 303 } 304 nfsm_srvfhtom(fhp); 305 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 306 nfsm_srvfillattr; 307 nfsm_srvdone; 308 } 309 310 /* 311 * nfs readlink service 312 */ 313 nfsrv_readlink(nfsd, mrep, md, dpos, cred, nam, mrq) 314 struct nfsd *nfsd; 315 struct mbuf *mrep, *md; 316 caddr_t dpos; 317 struct ucred *cred; 318 struct mbuf *nam, **mrq; 319 { 320 struct iovec iv[(NFS_MAXPATHLEN+MLEN-1)/MLEN]; 321 register struct iovec *ivp = iv; 322 register struct mbuf *mp; 323 register u_long *tl; 324 register long t1; 325 caddr_t bpos; 326 int error = 0, rdonly, cache, i, tlen, len; 327 char *cp2; 328 struct mbuf *mb, *mb2, *mp2, *mp3, *mreq; 329 struct vnode *vp; 330 nfsv2fh_t nfh; 331 fhandle_t *fhp; 332 struct uio io, *uiop = &io; 333 u_quad_t frev; 334 335 fhp = &nfh.fh_generic; 336 nfsm_srvmtofh(fhp); 337 len = 0; 338 i = 0; 339 while (len < NFS_MAXPATHLEN) { 340 MGET(mp, M_WAIT, MT_DATA); 341 MCLGET(mp, M_WAIT); 342 mp->m_len = NFSMSIZ(mp); 343 if (len == 0) 344 mp3 = mp2 = mp; 345 else { 346 mp2->m_next = mp; 347 mp2 = mp; 348 } 349 if ((len+mp->m_len) > NFS_MAXPATHLEN) { 350 mp->m_len = NFS_MAXPATHLEN-len; 351 len = NFS_MAXPATHLEN; 352 } else 353 len += mp->m_len; 354 ivp->iov_base = mtod(mp, caddr_t); 355 ivp->iov_len = mp->m_len; 356 i++; 357 ivp++; 358 } 359 uiop->uio_iov = iv; 360 uiop->uio_iovcnt = i; 361 uiop->uio_offset = 0; 362 uiop->uio_resid = len; 363 uiop->uio_rw = UIO_READ; 364 uiop->uio_segflg = UIO_SYSSPACE; 365 uiop->uio_procp = (struct proc *)0; 366 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) { 367 m_freem(mp3); 368 nfsm_reply(0); 369 } 370 if (vp->v_type != VLNK) { 371 error = EINVAL; 372 goto out; 373 } 374 nqsrv_getl(vp, NQL_READ); 375 error = VOP_READLINK(vp, uiop, cred); 376 out: 377 vput(vp); 378 if (error) 379 m_freem(mp3); 380 nfsm_reply(NFSX_UNSIGNED); 381 if (uiop->uio_resid > 0) { 382 len -= uiop->uio_resid; 383 tlen = nfsm_rndup(len); 384 nfsm_adj(mp3, NFS_MAXPATHLEN-tlen, tlen-len); 385 } 386 nfsm_build(tl, u_long *, NFSX_UNSIGNED); 387 *tl = txdr_unsigned(len); 388 mb->m_next = mp3; 389 nfsm_srvdone; 390 } 391 392 /* 393 * nfs read service 394 */ 395 nfsrv_read(nfsd, mrep, md, dpos, cred, nam, mrq) 396 struct nfsd *nfsd; 397 struct mbuf *mrep, *md; 398 caddr_t dpos; 399 struct ucred *cred; 400 struct mbuf *nam, **mrq; 401 { 402 register struct iovec *iv; 403 struct iovec *iv2; 404 register struct mbuf *m; 405 register struct nfsv2_fattr *fp; 406 register u_long *tl; 407 register long t1; 408 caddr_t bpos; 409 int error = 0, rdonly, cache, i, cnt, len, left, siz, tlen; 410 char *cp2; 411 struct mbuf *mb, *mb2, *mreq; 412 struct mbuf *m2; 413 struct vnode *vp; 414 nfsv2fh_t nfh; 415 fhandle_t *fhp; 416 struct uio io, *uiop = &io; 417 struct vattr va, *vap = &va; 418 off_t off; 419 u_quad_t frev; 420 421 fhp = &nfh.fh_generic; 422 nfsm_srvmtofh(fhp); 423 if (nfsd->nd_nqlflag == NQL_NOVAL) { 424 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED); 425 off = (off_t)fxdr_unsigned(u_long, *tl); 426 } else { 427 nfsm_dissect(tl, u_long *, 2 * NFSX_UNSIGNED); 428 fxdr_hyper(tl, &off); 429 } 430 nfsm_srvstrsiz(cnt, NFS_MAXDATA); 431 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 432 nfsm_reply(0); 433 if (vp->v_type != VREG) { 434 error = (vp->v_type == VDIR) ? EISDIR : EACCES; 435 vput(vp); 436 nfsm_reply(0); 437 } 438 nqsrv_getl(vp, NQL_READ); 439 if ((error = nfsrv_access(vp, VREAD, cred, rdonly, nfsd->nd_procp)) && 440 (error = nfsrv_access(vp, VEXEC, cred, rdonly, nfsd->nd_procp))) { 441 vput(vp); 442 nfsm_reply(0); 443 } 444 if (error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp)) { 445 vput(vp); 446 nfsm_reply(0); 447 } 448 if (off >= vap->va_size) 449 cnt = 0; 450 else if ((off + cnt) > vap->va_size) 451 cnt = nfsm_rndup(vap->va_size - off); 452 nfsm_reply(NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)+NFSX_UNSIGNED+nfsm_rndup(cnt)); 453 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 454 nfsm_build(tl, u_long *, NFSX_UNSIGNED); 455 len = left = cnt; 456 if (cnt > 0) { 457 /* 458 * Generate the mbuf list with the uio_iov ref. to it. 459 */ 460 i = 0; 461 m = m2 = mb; 462 MALLOC(iv, struct iovec *, 463 ((NFS_MAXDATA+MLEN-1)/MLEN) * sizeof (struct iovec), 464 M_TEMP, M_WAITOK); 465 iv2 = iv; 466 while (left > 0) { 467 siz = min(M_TRAILINGSPACE(m), left); 468 if (siz > 0) { 469 m->m_len += siz; 470 iv->iov_base = bpos; 471 iv->iov_len = siz; 472 iv++; 473 i++; 474 left -= siz; 475 } 476 if (left > 0) { 477 MGET(m, M_WAIT, MT_DATA); 478 MCLGET(m, M_WAIT); 479 m->m_len = 0; 480 m2->m_next = m; 481 m2 = m; 482 bpos = mtod(m, caddr_t); 483 } 484 } 485 uiop->uio_iov = iv2; 486 uiop->uio_iovcnt = i; 487 uiop->uio_offset = off; 488 uiop->uio_resid = cnt; 489 uiop->uio_rw = UIO_READ; 490 uiop->uio_segflg = UIO_SYSSPACE; 491 error = VOP_READ(vp, uiop, IO_NODELOCKED, cred); 492 off = uiop->uio_offset; 493 FREE((caddr_t)iv2, M_TEMP); 494 if (error || (error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp))) { 495 m_freem(mreq); 496 vput(vp); 497 nfsm_reply(0); 498 } 499 } else 500 uiop->uio_resid = 0; 501 vput(vp); 502 nfsm_srvfillattr; 503 len -= uiop->uio_resid; 504 tlen = nfsm_rndup(len); 505 if (cnt != tlen || tlen != len) 506 nfsm_adj(mb, cnt-tlen, tlen-len); 507 *tl = txdr_unsigned(len); 508 nfsm_srvdone; 509 } 510 511 /* 512 * nfs write service 513 */ 514 nfsrv_write(nfsd, mrep, md, dpos, cred, nam, mrq) 515 struct nfsd *nfsd; 516 struct mbuf *mrep, *md; 517 caddr_t dpos; 518 struct ucred *cred; 519 struct mbuf *nam, **mrq; 520 { 521 register struct iovec *ivp; 522 register struct mbuf *mp; 523 register struct nfsv2_fattr *fp; 524 struct iovec iv[NFS_MAXIOVEC]; 525 struct vattr va; 526 register struct vattr *vap = &va; 527 register u_long *tl; 528 register long t1; 529 caddr_t bpos; 530 int error = 0, rdonly, cache, siz, len, xfer; 531 int ioflags = IO_SYNC | IO_NODELOCKED; 532 char *cp2; 533 struct mbuf *mb, *mb2, *mreq; 534 struct vnode *vp; 535 nfsv2fh_t nfh; 536 fhandle_t *fhp; 537 struct uio io, *uiop = &io; 538 off_t off; 539 u_quad_t frev; 540 541 fhp = &nfh.fh_generic; 542 nfsm_srvmtofh(fhp); 543 nfsm_dissect(tl, u_long *, 4 * NFSX_UNSIGNED); 544 if (nfsd->nd_nqlflag == NQL_NOVAL) { 545 off = (off_t)fxdr_unsigned(u_long, *++tl); 546 tl += 2; 547 } else { 548 fxdr_hyper(tl, &off); 549 tl += 2; 550 if (fxdr_unsigned(u_long, *tl++)) 551 ioflags |= IO_APPEND; 552 } 553 len = fxdr_unsigned(long, *tl); 554 if (len > NFS_MAXDATA || len <= 0) { 555 error = EBADRPC; 556 nfsm_reply(0); 557 } 558 if (dpos == (mtod(md, caddr_t)+md->m_len)) { 559 mp = md->m_next; 560 if (mp == NULL) { 561 error = EBADRPC; 562 nfsm_reply(0); 563 } 564 } else { 565 mp = md; 566 siz = dpos-mtod(mp, caddr_t); 567 mp->m_len -= siz; 568 NFSMADV(mp, siz); 569 } 570 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 571 nfsm_reply(0); 572 if (vp->v_type != VREG) { 573 error = (vp->v_type == VDIR) ? EISDIR : EACCES; 574 vput(vp); 575 nfsm_reply(0); 576 } 577 nqsrv_getl(vp, NQL_WRITE); 578 if (error = nfsrv_access(vp, VWRITE, cred, rdonly, nfsd->nd_procp)) { 579 vput(vp); 580 nfsm_reply(0); 581 } 582 uiop->uio_resid = 0; 583 uiop->uio_rw = UIO_WRITE; 584 uiop->uio_segflg = UIO_SYSSPACE; 585 uiop->uio_procp = (struct proc *)0; 586 /* 587 * Do up to NFS_MAXIOVEC mbufs of write each iteration of the 588 * loop until done. 589 */ 590 while (len > 0 && uiop->uio_resid == 0) { 591 ivp = iv; 592 siz = 0; 593 uiop->uio_iov = ivp; 594 uiop->uio_iovcnt = 0; 595 uiop->uio_offset = off; 596 while (len > 0 && uiop->uio_iovcnt < NFS_MAXIOVEC && mp != NULL) { 597 ivp->iov_base = mtod(mp, caddr_t); 598 if (len < mp->m_len) 599 ivp->iov_len = xfer = len; 600 else 601 ivp->iov_len = xfer = mp->m_len; 602 #ifdef notdef 603 /* Not Yet .. */ 604 if (M_HASCL(mp) && (((u_long)ivp->iov_base) & CLOFSET) == 0) 605 ivp->iov_op = NULL; /* what should it be ?? */ 606 else 607 ivp->iov_op = NULL; 608 #endif 609 uiop->uio_iovcnt++; 610 ivp++; 611 len -= xfer; 612 siz += xfer; 613 mp = mp->m_next; 614 } 615 if (len > 0 && mp == NULL) { 616 error = EBADRPC; 617 vput(vp); 618 nfsm_reply(0); 619 } 620 uiop->uio_resid = siz; 621 if (error = VOP_WRITE(vp, uiop, ioflags, cred)) { 622 vput(vp); 623 nfsm_reply(0); 624 } 625 off = uiop->uio_offset; 626 } 627 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 628 vput(vp); 629 nfsm_reply(NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 630 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 631 nfsm_srvfillattr; 632 if (nfsd->nd_nqlflag != NQL_NOVAL) { 633 nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED); 634 txdr_hyper(&vap->va_filerev, tl); 635 } 636 nfsm_srvdone; 637 } 638 639 /* 640 * nfs create service 641 * now does a truncate to 0 length via. setattr if it already exists 642 */ 643 nfsrv_create(nfsd, mrep, md, dpos, cred, nam, mrq) 644 struct nfsd *nfsd; 645 struct mbuf *mrep, *md; 646 caddr_t dpos; 647 struct ucred *cred; 648 struct mbuf *nam, **mrq; 649 { 650 register struct nfsv2_fattr *fp; 651 struct vattr va; 652 register struct vattr *vap = &va; 653 register struct nfsv2_sattr *sp; 654 register u_long *tl; 655 struct nameidata nd; 656 register caddr_t cp; 657 register long t1; 658 caddr_t bpos; 659 int error = 0, rdev, cache, len, tsize; 660 char *cp2; 661 struct mbuf *mb, *mb2, *mreq; 662 struct vnode *vp; 663 nfsv2fh_t nfh; 664 fhandle_t *fhp; 665 u_quad_t frev; 666 667 nd.ni_cnd.cn_nameiop = 0; 668 fhp = &nfh.fh_generic; 669 nfsm_srvmtofh(fhp); 670 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 671 nd.ni_cnd.cn_cred = cred; 672 nd.ni_cnd.cn_nameiop = CREATE; 673 nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | SAVESTART; 674 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 675 nfsd->nd_procp)) 676 nfsm_reply(0); 677 VATTR_NULL(vap); 678 nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_SATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 679 /* 680 * Iff doesn't exist, create it 681 * otherwise just truncate to 0 length 682 * should I set the mode too ?? 683 */ 684 if (nd.ni_vp == NULL) { 685 vap->va_type = IFTOVT(fxdr_unsigned(u_long, sp->sa_mode)); 686 if (vap->va_type == VNON) 687 vap->va_type = VREG; 688 vap->va_mode = nfstov_mode(sp->sa_mode); 689 if (nfsd->nd_nqlflag == NQL_NOVAL) 690 rdev = fxdr_unsigned(long, sp->sa_nfssize); 691 else 692 rdev = fxdr_unsigned(long, sp->sa_nqrdev); 693 if (vap->va_type == VREG || vap->va_type == VSOCK) { 694 vrele(nd.ni_startdir); 695 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 696 if (error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap)) 697 nfsm_reply(0); 698 FREE(nd.ni_cnd.cn_pnbuf, M_NAMEI); 699 } else if (vap->va_type == VCHR || vap->va_type == VBLK || 700 vap->va_type == VFIFO) { 701 if (vap->va_type == VCHR && rdev == 0xffffffff) 702 vap->va_type = VFIFO; 703 if (vap->va_type == VFIFO) { 704 #ifndef FIFO 705 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 706 vput(nd.ni_dvp); 707 error = ENXIO; 708 goto out; 709 #endif /* FIFO */ 710 } else if (error = suser(cred, (u_short *)0)) { 711 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 712 vput(nd.ni_dvp); 713 goto out; 714 } else 715 vap->va_rdev = (dev_t)rdev; 716 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 717 if (error = VOP_MKNOD(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap)) { 718 vrele(nd.ni_startdir); 719 nfsm_reply(0); 720 } 721 nd.ni_cnd.cn_nameiop = LOOKUP; 722 nd.ni_cnd.cn_flags &= ~(LOCKPARENT | SAVESTART); 723 nd.ni_cnd.cn_proc = nfsd->nd_procp; 724 nd.ni_cnd.cn_cred = nfsd->nd_procp->p_ucred; 725 if (error = lookup(&nd)) { 726 free(nd.ni_cnd.cn_pnbuf, M_NAMEI); 727 nfsm_reply(0); 728 } 729 FREE(nd.ni_cnd.cn_pnbuf, M_NAMEI); 730 if (nd.ni_cnd.cn_flags & ISSYMLINK) { 731 vrele(nd.ni_dvp); 732 vput(nd.ni_vp); 733 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 734 error = EINVAL; 735 nfsm_reply(0); 736 } 737 } else { 738 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 739 vput(nd.ni_dvp); 740 error = ENXIO; 741 goto out; 742 } 743 vp = nd.ni_vp; 744 } else { 745 vrele(nd.ni_startdir); 746 free(nd.ni_cnd.cn_pnbuf, M_NAMEI); 747 vp = nd.ni_vp; 748 if (nd.ni_dvp == vp) 749 vrele(nd.ni_dvp); 750 else 751 vput(nd.ni_dvp); 752 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 753 if (nfsd->nd_nqlflag == NQL_NOVAL) { 754 tsize = fxdr_unsigned(long, sp->sa_nfssize); 755 if (tsize != -1) 756 vap->va_size = (u_quad_t)tsize; 757 else 758 vap->va_size = -1; 759 } else 760 fxdr_hyper(&sp->sa_nqsize, &vap->va_size); 761 if (vap->va_size != -1) { 762 nqsrv_getl(vp, NQL_WRITE); 763 if (error = VOP_SETATTR(vp, vap, cred, nfsd->nd_procp)) { 764 vput(vp); 765 nfsm_reply(0); 766 } 767 } 768 } 769 bzero((caddr_t)fhp, sizeof(nfh)); 770 fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; 771 if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) { 772 vput(vp); 773 nfsm_reply(0); 774 } 775 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 776 vput(vp); 777 nfsm_reply(NFSX_FH+NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 778 nfsm_srvfhtom(fhp); 779 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 780 nfsm_srvfillattr; 781 return (error); 782 nfsmout: 783 if (nd.ni_cnd.cn_nameiop || nd.ni_cnd.cn_flags) 784 vrele(nd.ni_startdir); 785 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 786 if (nd.ni_dvp == nd.ni_vp) 787 vrele(nd.ni_dvp); 788 else 789 vput(nd.ni_dvp); 790 if (nd.ni_vp) 791 vput(nd.ni_vp); 792 return (error); 793 794 out: 795 vrele(nd.ni_startdir); 796 free(nd.ni_cnd.cn_pnbuf, M_NAMEI); 797 nfsm_reply(0); 798 } 799 800 /* 801 * nfs remove service 802 */ 803 nfsrv_remove(nfsd, mrep, md, dpos, cred, nam, mrq) 804 struct nfsd *nfsd; 805 struct mbuf *mrep, *md; 806 caddr_t dpos; 807 struct ucred *cred; 808 struct mbuf *nam, **mrq; 809 { 810 struct nameidata nd; 811 register u_long *tl; 812 register long t1; 813 caddr_t bpos; 814 int error = 0, cache, len; 815 char *cp2; 816 struct mbuf *mb, *mreq; 817 struct vnode *vp; 818 nfsv2fh_t nfh; 819 fhandle_t *fhp; 820 u_quad_t frev; 821 822 fhp = &nfh.fh_generic; 823 nfsm_srvmtofh(fhp); 824 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 825 nd.ni_cnd.cn_cred = cred; 826 nd.ni_cnd.cn_nameiop = DELETE; 827 nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; 828 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 829 nfsd->nd_procp)) 830 nfsm_reply(0); 831 vp = nd.ni_vp; 832 if (vp->v_type == VDIR && 833 (error = suser(cred, (u_short *)0))) 834 goto out; 835 /* 836 * The root of a mounted filesystem cannot be deleted. 837 */ 838 if (vp->v_flag & VROOT) { 839 error = EBUSY; 840 goto out; 841 } 842 if (vp->v_flag & VTEXT) 843 (void) vnode_pager_uncache(vp); 844 out: 845 if (!error) { 846 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 847 nqsrv_getl(vp, NQL_WRITE); 848 error = VOP_REMOVE(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); 849 } else { 850 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 851 if (nd.ni_dvp == vp) 852 vrele(nd.ni_dvp); 853 else 854 vput(nd.ni_dvp); 855 vput(vp); 856 } 857 nfsm_reply(0); 858 nfsm_srvdone; 859 } 860 861 /* 862 * nfs rename service 863 */ 864 nfsrv_rename(nfsd, mrep, md, dpos, cred, nam, mrq) 865 struct nfsd *nfsd; 866 struct mbuf *mrep, *md; 867 caddr_t dpos; 868 struct ucred *cred; 869 struct mbuf *nam, **mrq; 870 { 871 register u_long *tl; 872 register long t1; 873 caddr_t bpos; 874 int error = 0, rdonly, cache, len, len2; 875 char *cp2; 876 struct mbuf *mb, *mreq; 877 struct nameidata fromnd, tond; 878 struct vnode *fvp, *tvp, *tdvp; 879 nfsv2fh_t fnfh, tnfh; 880 fhandle_t *ffhp, *tfhp; 881 u_quad_t frev; 882 uid_t saved_uid; 883 884 ffhp = &fnfh.fh_generic; 885 tfhp = &tnfh.fh_generic; 886 fromnd.ni_cnd.cn_nameiop = 0; 887 tond.ni_cnd.cn_nameiop = 0; 888 nfsm_srvmtofh(ffhp); 889 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 890 /* 891 * Remember our original uid so that we can reset cr_uid before 892 * the second nfs_namei() call, in case it is remapped. 893 */ 894 saved_uid = cred->cr_uid; 895 fromnd.ni_cnd.cn_cred = cred; 896 fromnd.ni_cnd.cn_nameiop = DELETE; 897 fromnd.ni_cnd.cn_flags = WANTPARENT | SAVESTART; 898 if (error = nfs_namei(&fromnd, ffhp, len, nfsd->nd_slp, nam, &md, 899 &dpos, nfsd->nd_procp)) 900 nfsm_reply(0); 901 fvp = fromnd.ni_vp; 902 nfsm_srvmtofh(tfhp); 903 nfsm_strsiz(len2, NFS_MAXNAMLEN); 904 cred->cr_uid = saved_uid; 905 tond.ni_cnd.cn_cred = cred; 906 tond.ni_cnd.cn_nameiop = RENAME; 907 tond.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | NOCACHE | SAVESTART; 908 if (error = nfs_namei(&tond, tfhp, len2, nfsd->nd_slp, nam, &md, 909 &dpos, nfsd->nd_procp)) { 910 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); 911 vrele(fromnd.ni_dvp); 912 vrele(fvp); 913 goto out1; 914 } 915 tdvp = tond.ni_dvp; 916 tvp = tond.ni_vp; 917 if (tvp != NULL) { 918 if (fvp->v_type == VDIR && tvp->v_type != VDIR) { 919 error = EISDIR; 920 goto out; 921 } else if (fvp->v_type != VDIR && tvp->v_type == VDIR) { 922 error = ENOTDIR; 923 goto out; 924 } 925 if (tvp->v_type == VDIR && tvp->v_mountedhere) { 926 error = EXDEV; 927 goto out; 928 } 929 } 930 if (fvp->v_type == VDIR && fvp->v_mountedhere) { 931 error = EBUSY; 932 goto out; 933 } 934 if (fvp->v_mount != tdvp->v_mount) { 935 error = EXDEV; 936 goto out; 937 } 938 if (fvp == tdvp) 939 error = EINVAL; 940 /* 941 * If source is the same as the destination (that is the 942 * same vnode with the same name in the same directory), 943 * then there is nothing to do. 944 */ 945 if (fvp == tvp && fromnd.ni_dvp == tdvp && 946 fromnd.ni_cnd.cn_namelen == tond.ni_cnd.cn_namelen && 947 !bcmp(fromnd.ni_cnd.cn_nameptr, tond.ni_cnd.cn_nameptr, 948 fromnd.ni_cnd.cn_namelen)) 949 error = -1; 950 out: 951 if (!error) { 952 nqsrv_getl(fromnd.ni_dvp, NQL_WRITE); 953 nqsrv_getl(tdvp, NQL_WRITE); 954 if (tvp) 955 nqsrv_getl(tvp, NQL_WRITE); 956 error = VOP_RENAME(fromnd.ni_dvp, fromnd.ni_vp, &fromnd.ni_cnd, 957 tond.ni_dvp, tond.ni_vp, &tond.ni_cnd); 958 } else { 959 VOP_ABORTOP(tond.ni_dvp, &tond.ni_cnd); 960 if (tdvp == tvp) 961 vrele(tdvp); 962 else 963 vput(tdvp); 964 if (tvp) 965 vput(tvp); 966 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); 967 vrele(fromnd.ni_dvp); 968 vrele(fvp); 969 } 970 vrele(tond.ni_startdir); 971 FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI); 972 out1: 973 vrele(fromnd.ni_startdir); 974 FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI); 975 nfsm_reply(0); 976 return (error); 977 978 nfsmout: 979 if (tond.ni_cnd.cn_nameiop || tond.ni_cnd.cn_flags) { 980 vrele(tond.ni_startdir); 981 FREE(tond.ni_cnd.cn_pnbuf, M_NAMEI); 982 } 983 if (fromnd.ni_cnd.cn_nameiop || fromnd.ni_cnd.cn_flags) { 984 vrele(fromnd.ni_startdir); 985 FREE(fromnd.ni_cnd.cn_pnbuf, M_NAMEI); 986 VOP_ABORTOP(fromnd.ni_dvp, &fromnd.ni_cnd); 987 vrele(fromnd.ni_dvp); 988 vrele(fvp); 989 } 990 return (error); 991 } 992 993 /* 994 * nfs link service 995 */ 996 nfsrv_link(nfsd, mrep, md, dpos, cred, nam, mrq) 997 struct nfsd *nfsd; 998 struct mbuf *mrep, *md; 999 caddr_t dpos; 1000 struct ucred *cred; 1001 struct mbuf *nam, **mrq; 1002 { 1003 struct nameidata nd; 1004 register u_long *tl; 1005 register long t1; 1006 caddr_t bpos; 1007 int error = 0, rdonly, cache, len; 1008 char *cp2; 1009 struct mbuf *mb, *mreq; 1010 struct vnode *vp, *xp; 1011 nfsv2fh_t nfh, dnfh; 1012 fhandle_t *fhp, *dfhp; 1013 u_quad_t frev; 1014 1015 fhp = &nfh.fh_generic; 1016 dfhp = &dnfh.fh_generic; 1017 nfsm_srvmtofh(fhp); 1018 nfsm_srvmtofh(dfhp); 1019 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 1020 if (error = nfsrv_fhtovp(fhp, FALSE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 1021 nfsm_reply(0); 1022 if (vp->v_type == VDIR && (error = suser(cred, (u_short *)0))) 1023 goto out1; 1024 nd.ni_cnd.cn_cred = cred; 1025 nd.ni_cnd.cn_nameiop = CREATE; 1026 nd.ni_cnd.cn_flags = LOCKPARENT; 1027 if (error = nfs_namei(&nd, dfhp, len, nfsd->nd_slp, nam, &md, &dpos, 1028 nfsd->nd_procp)) 1029 goto out1; 1030 xp = nd.ni_vp; 1031 if (xp != NULL) { 1032 error = EEXIST; 1033 goto out; 1034 } 1035 xp = nd.ni_dvp; 1036 if (vp->v_mount != xp->v_mount) 1037 error = EXDEV; 1038 out: 1039 if (!error) { 1040 nqsrv_getl(vp, NQL_WRITE); 1041 nqsrv_getl(xp, NQL_WRITE); 1042 error = VOP_LINK(nd.ni_dvp, vp, &nd.ni_cnd); 1043 } else { 1044 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1045 if (nd.ni_dvp == nd.ni_vp) 1046 vrele(nd.ni_dvp); 1047 else 1048 vput(nd.ni_dvp); 1049 if (nd.ni_vp) 1050 vrele(nd.ni_vp); 1051 } 1052 out1: 1053 vrele(vp); 1054 nfsm_reply(0); 1055 nfsm_srvdone; 1056 } 1057 1058 /* 1059 * nfs symbolic link service 1060 */ 1061 nfsrv_symlink(nfsd, mrep, md, dpos, cred, nam, mrq) 1062 struct nfsd *nfsd; 1063 struct mbuf *mrep, *md; 1064 caddr_t dpos; 1065 struct ucred *cred; 1066 struct mbuf *nam, **mrq; 1067 { 1068 struct vattr va; 1069 struct nameidata nd; 1070 register struct vattr *vap = &va; 1071 register u_long *tl; 1072 register long t1; 1073 struct nfsv2_sattr *sp; 1074 caddr_t bpos; 1075 struct uio io; 1076 struct iovec iv; 1077 int error = 0, rdonly, cache, len, len2; 1078 char *pathcp, *cp2; 1079 struct mbuf *mb, *mreq; 1080 nfsv2fh_t nfh; 1081 fhandle_t *fhp; 1082 u_quad_t frev; 1083 1084 pathcp = (char *)0; 1085 fhp = &nfh.fh_generic; 1086 nfsm_srvmtofh(fhp); 1087 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 1088 nd.ni_cnd.cn_cred = cred; 1089 nd.ni_cnd.cn_nameiop = CREATE; 1090 nd.ni_cnd.cn_flags = LOCKPARENT; 1091 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 1092 nfsd->nd_procp)) 1093 goto out; 1094 nfsm_strsiz(len2, NFS_MAXPATHLEN); 1095 MALLOC(pathcp, caddr_t, len2 + 1, M_TEMP, M_WAITOK); 1096 iv.iov_base = pathcp; 1097 iv.iov_len = len2; 1098 io.uio_resid = len2; 1099 io.uio_offset = 0; 1100 io.uio_iov = &iv; 1101 io.uio_iovcnt = 1; 1102 io.uio_segflg = UIO_SYSSPACE; 1103 io.uio_rw = UIO_READ; 1104 io.uio_procp = (struct proc *)0; 1105 nfsm_mtouio(&io, len2); 1106 nfsm_dissect(sp, struct nfsv2_sattr *, NFSX_SATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 1107 *(pathcp + len2) = '\0'; 1108 if (nd.ni_vp) { 1109 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1110 if (nd.ni_dvp == nd.ni_vp) 1111 vrele(nd.ni_dvp); 1112 else 1113 vput(nd.ni_dvp); 1114 vrele(nd.ni_vp); 1115 error = EEXIST; 1116 goto out; 1117 } 1118 VATTR_NULL(vap); 1119 vap->va_mode = fxdr_unsigned(u_short, sp->sa_mode); 1120 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 1121 error = VOP_SYMLINK(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap, pathcp); 1122 out: 1123 if (pathcp) 1124 FREE(pathcp, M_TEMP); 1125 nfsm_reply(0); 1126 return (error); 1127 nfsmout: 1128 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1129 if (nd.ni_dvp == nd.ni_vp) 1130 vrele(nd.ni_dvp); 1131 else 1132 vput(nd.ni_dvp); 1133 if (nd.ni_vp) 1134 vrele(nd.ni_vp); 1135 if (pathcp) 1136 FREE(pathcp, M_TEMP); 1137 return (error); 1138 } 1139 1140 /* 1141 * nfs mkdir service 1142 */ 1143 nfsrv_mkdir(nfsd, mrep, md, dpos, cred, nam, mrq) 1144 struct nfsd *nfsd; 1145 struct mbuf *mrep, *md; 1146 caddr_t dpos; 1147 struct ucred *cred; 1148 struct mbuf *nam, **mrq; 1149 { 1150 struct vattr va; 1151 register struct vattr *vap = &va; 1152 register struct nfsv2_fattr *fp; 1153 struct nameidata nd; 1154 register caddr_t cp; 1155 register u_long *tl; 1156 register long t1; 1157 caddr_t bpos; 1158 int error = 0, rdonly, cache, len; 1159 char *cp2; 1160 struct mbuf *mb, *mb2, *mreq; 1161 struct vnode *vp; 1162 nfsv2fh_t nfh; 1163 fhandle_t *fhp; 1164 u_quad_t frev; 1165 1166 fhp = &nfh.fh_generic; 1167 nfsm_srvmtofh(fhp); 1168 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 1169 nd.ni_cnd.cn_cred = cred; 1170 nd.ni_cnd.cn_nameiop = CREATE; 1171 nd.ni_cnd.cn_flags = LOCKPARENT; 1172 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 1173 nfsd->nd_procp)) 1174 nfsm_reply(0); 1175 nfsm_dissect(tl, u_long *, NFSX_UNSIGNED); 1176 VATTR_NULL(vap); 1177 vap->va_type = VDIR; 1178 vap->va_mode = nfstov_mode(*tl++); 1179 vp = nd.ni_vp; 1180 if (vp != NULL) { 1181 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1182 if (nd.ni_dvp == vp) 1183 vrele(nd.ni_dvp); 1184 else 1185 vput(nd.ni_dvp); 1186 vrele(vp); 1187 error = EEXIST; 1188 nfsm_reply(0); 1189 } 1190 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 1191 if (error = VOP_MKDIR(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, vap)) 1192 nfsm_reply(0); 1193 vp = nd.ni_vp; 1194 bzero((caddr_t)fhp, sizeof(nfh)); 1195 fhp->fh_fsid = vp->v_mount->mnt_stat.f_fsid; 1196 if (error = VFS_VPTOFH(vp, &fhp->fh_fid)) { 1197 vput(vp); 1198 nfsm_reply(0); 1199 } 1200 error = VOP_GETATTR(vp, vap, cred, nfsd->nd_procp); 1201 vput(vp); 1202 nfsm_reply(NFSX_FH+NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 1203 nfsm_srvfhtom(fhp); 1204 nfsm_build(fp, struct nfsv2_fattr *, NFSX_FATTR(nfsd->nd_nqlflag != NQL_NOVAL)); 1205 nfsm_srvfillattr; 1206 return (error); 1207 nfsmout: 1208 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1209 if (nd.ni_dvp == nd.ni_vp) 1210 vrele(nd.ni_dvp); 1211 else 1212 vput(nd.ni_dvp); 1213 if (nd.ni_vp) 1214 vrele(nd.ni_vp); 1215 return (error); 1216 } 1217 1218 /* 1219 * nfs rmdir service 1220 */ 1221 nfsrv_rmdir(nfsd, mrep, md, dpos, cred, nam, mrq) 1222 struct nfsd *nfsd; 1223 struct mbuf *mrep, *md; 1224 caddr_t dpos; 1225 struct ucred *cred; 1226 struct mbuf *nam, **mrq; 1227 { 1228 register u_long *tl; 1229 register long t1; 1230 caddr_t bpos; 1231 int error = 0, rdonly, cache, len; 1232 char *cp2; 1233 struct mbuf *mb, *mreq; 1234 struct vnode *vp; 1235 nfsv2fh_t nfh; 1236 fhandle_t *fhp; 1237 struct nameidata nd; 1238 u_quad_t frev; 1239 1240 fhp = &nfh.fh_generic; 1241 nfsm_srvmtofh(fhp); 1242 nfsm_srvstrsiz(len, NFS_MAXNAMLEN); 1243 nd.ni_cnd.cn_cred = cred; 1244 nd.ni_cnd.cn_nameiop = DELETE; 1245 nd.ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF; 1246 if (error = nfs_namei(&nd, fhp, len, nfsd->nd_slp, nam, &md, &dpos, 1247 nfsd->nd_procp)) 1248 nfsm_reply(0); 1249 vp = nd.ni_vp; 1250 if (vp->v_type != VDIR) { 1251 error = ENOTDIR; 1252 goto out; 1253 } 1254 /* 1255 * No rmdir "." please. 1256 */ 1257 if (nd.ni_dvp == vp) { 1258 error = EINVAL; 1259 goto out; 1260 } 1261 /* 1262 * The root of a mounted filesystem cannot be deleted. 1263 */ 1264 if (vp->v_flag & VROOT) 1265 error = EBUSY; 1266 out: 1267 if (!error) { 1268 nqsrv_getl(nd.ni_dvp, NQL_WRITE); 1269 nqsrv_getl(vp, NQL_WRITE); 1270 error = VOP_RMDIR(nd.ni_dvp, nd.ni_vp, &nd.ni_cnd); 1271 } else { 1272 VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd); 1273 if (nd.ni_dvp == nd.ni_vp) 1274 vrele(nd.ni_dvp); 1275 else 1276 vput(nd.ni_dvp); 1277 vput(vp); 1278 } 1279 nfsm_reply(0); 1280 nfsm_srvdone; 1281 } 1282 1283 /* 1284 * nfs readdir service 1285 * - mallocs what it thinks is enough to read 1286 * count rounded up to a multiple of NFS_DIRBLKSIZ <= NFS_MAXREADDIR 1287 * - calls VOP_READDIR() 1288 * - loops around building the reply 1289 * if the output generated exceeds count break out of loop 1290 * The nfsm_clget macro is used here so that the reply will be packed 1291 * tightly in mbuf clusters. 1292 * - it only knows that it has encountered eof when the VOP_READDIR() 1293 * reads nothing 1294 * - as such one readdir rpc will return eof false although you are there 1295 * and then the next will return eof 1296 * - it trims out records with d_fileno == 0 1297 * this doesn't matter for Unix clients, but they might confuse clients 1298 * for other os'. 1299 * NB: It is tempting to set eof to true if the VOP_READDIR() reads less 1300 * than requested, but this may not apply to all filesystems. For 1301 * example, client NFS does not { although it is never remote mounted 1302 * anyhow } 1303 * The alternate call nqnfsrv_readdirlook() does lookups as well. 1304 * PS: The NFS protocol spec. does not clarify what the "count" byte 1305 * argument is a count of.. just name strings and file id's or the 1306 * entire reply rpc or ... 1307 * I tried just file name and id sizes and it confused the Sun client, 1308 * so I am using the full rpc size now. The "paranoia.." comment refers 1309 * to including the status longwords that are not a part of the dir. 1310 * "entry" structures, but are in the rpc. 1311 */ 1312 struct flrep { 1313 u_long fl_cachable; 1314 u_long fl_duration; 1315 u_long fl_frev[2]; 1316 nfsv2fh_t fl_nfh; 1317 u_long fl_fattr[NFSX_NQFATTR / sizeof (u_long)]; 1318 }; 1319 1320 nfsrv_readdir(nfsd, mrep, md, dpos, cred, nam, mrq) 1321 struct nfsd *nfsd; 1322 struct mbuf *mrep, *md; 1323 caddr_t dpos; 1324 struct ucred *cred; 1325 struct mbuf *nam, **mrq; 1326 { 1327 register char *bp, *be; 1328 register struct mbuf *mp; 1329 register struct dirent *dp; 1330 register caddr_t cp; 1331 register u_long *tl; 1332 register long t1; 1333 caddr_t bpos; 1334 struct mbuf *mb, *mb2, *mreq, *mp2; 1335 char *cpos, *cend, *cp2, *rbuf; 1336 struct vnode *vp; 1337 nfsv2fh_t nfh; 1338 fhandle_t *fhp; 1339 struct uio io; 1340 struct iovec iv; 1341 struct vattr va; 1342 int len, nlen, rem, xfer, tsiz, i, error = 0; 1343 int siz, cnt, fullsiz, eofflag, rdonly, cache; 1344 u_quad_t frev; 1345 u_long on, off, toff; 1346 1347 fhp = &nfh.fh_generic; 1348 nfsm_srvmtofh(fhp); 1349 nfsm_dissect(tl, u_long *, 2*NFSX_UNSIGNED); 1350 toff = fxdr_unsigned(u_long, *tl++); 1351 off = (toff & ~(NFS_DIRBLKSIZ-1)); 1352 on = (toff & (NFS_DIRBLKSIZ-1)); 1353 cnt = fxdr_unsigned(int, *tl); 1354 siz = ((cnt+NFS_DIRBLKSIZ-1) & ~(NFS_DIRBLKSIZ-1)); 1355 if (cnt > NFS_MAXREADDIR) 1356 siz = NFS_MAXREADDIR; 1357 fullsiz = siz; 1358 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 1359 nfsm_reply(0); 1360 nqsrv_getl(vp, NQL_READ); 1361 if (error = nfsrv_access(vp, VEXEC, cred, rdonly, nfsd->nd_procp)) { 1362 vput(vp); 1363 nfsm_reply(0); 1364 } 1365 VOP_UNLOCK(vp); 1366 MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK); 1367 again: 1368 iv.iov_base = rbuf; 1369 iv.iov_len = fullsiz; 1370 io.uio_iov = &iv; 1371 io.uio_iovcnt = 1; 1372 io.uio_offset = (off_t)off; 1373 io.uio_resid = fullsiz; 1374 io.uio_segflg = UIO_SYSSPACE; 1375 io.uio_rw = UIO_READ; 1376 io.uio_procp = (struct proc *)0; 1377 error = VOP_READDIR(vp, &io, cred); 1378 off = (off_t)io.uio_offset; 1379 if (error) { 1380 vrele(vp); 1381 free((caddr_t)rbuf, M_TEMP); 1382 nfsm_reply(0); 1383 } 1384 if (io.uio_resid < fullsiz) 1385 eofflag = 0; 1386 else 1387 eofflag = 1; 1388 if (io.uio_resid) { 1389 siz -= io.uio_resid; 1390 1391 /* 1392 * If nothing read, return eof 1393 * rpc reply 1394 */ 1395 if (siz == 0) { 1396 vrele(vp); 1397 nfsm_reply(2*NFSX_UNSIGNED); 1398 nfsm_build(tl, u_long *, 2*NFSX_UNSIGNED); 1399 *tl++ = nfs_false; 1400 *tl = nfs_true; 1401 FREE((caddr_t)rbuf, M_TEMP); 1402 return (0); 1403 } 1404 } 1405 1406 /* 1407 * Check for degenerate cases of nothing useful read. 1408 * If so go try again 1409 */ 1410 cpos = rbuf + on; 1411 cend = rbuf + siz; 1412 dp = (struct dirent *)cpos; 1413 while (cpos < cend && dp->d_fileno == 0) { 1414 cpos += dp->d_reclen; 1415 dp = (struct dirent *)cpos; 1416 } 1417 if (cpos >= cend) { 1418 toff = off; 1419 siz = fullsiz; 1420 on = 0; 1421 goto again; 1422 } 1423 1424 cpos = rbuf + on; 1425 cend = rbuf + siz; 1426 dp = (struct dirent *)cpos; 1427 len = 3*NFSX_UNSIGNED; /* paranoia, probably can be 0 */ 1428 nfsm_reply(siz); 1429 mp = mp2 = mb; 1430 bp = bpos; 1431 be = bp + M_TRAILINGSPACE(mp); 1432 1433 /* Loop through the records and build reply */ 1434 while (cpos < cend) { 1435 if (dp->d_fileno != 0) { 1436 nlen = dp->d_namlen; 1437 rem = nfsm_rndup(nlen)-nlen; 1438 len += (4*NFSX_UNSIGNED + nlen + rem); 1439 if (len > cnt) { 1440 eofflag = 0; 1441 break; 1442 } 1443 /* 1444 * Build the directory record xdr from 1445 * the dirent entry. 1446 */ 1447 nfsm_clget; 1448 *tl = nfs_true; 1449 bp += NFSX_UNSIGNED; 1450 nfsm_clget; 1451 *tl = txdr_unsigned(dp->d_fileno); 1452 bp += NFSX_UNSIGNED; 1453 nfsm_clget; 1454 *tl = txdr_unsigned(nlen); 1455 bp += NFSX_UNSIGNED; 1456 1457 /* And loop around copying the name */ 1458 xfer = nlen; 1459 cp = dp->d_name; 1460 while (xfer > 0) { 1461 nfsm_clget; 1462 if ((bp+xfer) > be) 1463 tsiz = be-bp; 1464 else 1465 tsiz = xfer; 1466 bcopy(cp, bp, tsiz); 1467 bp += tsiz; 1468 xfer -= tsiz; 1469 if (xfer > 0) 1470 cp += tsiz; 1471 } 1472 /* And null pad to a long boundary */ 1473 for (i = 0; i < rem; i++) 1474 *bp++ = '\0'; 1475 nfsm_clget; 1476 1477 /* Finish off the record */ 1478 toff += dp->d_reclen; 1479 *tl = txdr_unsigned(toff); 1480 bp += NFSX_UNSIGNED; 1481 } else 1482 toff += dp->d_reclen; 1483 cpos += dp->d_reclen; 1484 dp = (struct dirent *)cpos; 1485 } 1486 vrele(vp); 1487 nfsm_clget; 1488 *tl = nfs_false; 1489 bp += NFSX_UNSIGNED; 1490 nfsm_clget; 1491 if (eofflag) 1492 *tl = nfs_true; 1493 else 1494 *tl = nfs_false; 1495 bp += NFSX_UNSIGNED; 1496 if (mp != mb) { 1497 if (bp < be) 1498 mp->m_len = bp - mtod(mp, caddr_t); 1499 } else 1500 mp->m_len += bp - bpos; 1501 FREE(rbuf, M_TEMP); 1502 nfsm_srvdone; 1503 } 1504 1505 nqnfsrv_readdirlook(nfsd, mrep, md, dpos, cred, nam, mrq) 1506 struct nfsd *nfsd; 1507 struct mbuf *mrep, *md; 1508 caddr_t dpos; 1509 struct ucred *cred; 1510 struct mbuf *nam, **mrq; 1511 { 1512 register char *bp, *be; 1513 register struct mbuf *mp; 1514 register struct dirent *dp; 1515 register caddr_t cp; 1516 register u_long *tl; 1517 register long t1; 1518 caddr_t bpos; 1519 struct mbuf *mb, *mb2, *mreq, *mp2; 1520 char *cpos, *cend, *cp2, *rbuf; 1521 struct vnode *vp, *nvp; 1522 struct flrep fl; 1523 nfsv2fh_t nfh; 1524 fhandle_t *fhp; 1525 struct uio io; 1526 struct iovec iv; 1527 struct vattr va, *vap = &va; 1528 struct nfsv2_fattr *fp; 1529 int len, nlen, rem, xfer, tsiz, i, error = 0, duration2, cache2; 1530 int siz, cnt, fullsiz, eofflag, rdonly, cache; 1531 u_quad_t frev, frev2; 1532 u_long on, off, toff; 1533 1534 fhp = &nfh.fh_generic; 1535 nfsm_srvmtofh(fhp); 1536 nfsm_dissect(tl, u_long *, 3*NFSX_UNSIGNED); 1537 toff = fxdr_unsigned(u_long, *tl++); 1538 off = (toff & ~(NFS_DIRBLKSIZ-1)); 1539 on = (toff & (NFS_DIRBLKSIZ-1)); 1540 cnt = fxdr_unsigned(int, *tl++); 1541 duration2 = fxdr_unsigned(int, *tl); 1542 siz = ((cnt+NFS_DIRBLKSIZ-1) & ~(NFS_DIRBLKSIZ-1)); 1543 if (cnt > NFS_MAXREADDIR) 1544 siz = NFS_MAXREADDIR; 1545 fullsiz = siz; 1546 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 1547 nfsm_reply(0); 1548 nqsrv_getl(vp, NQL_READ); 1549 if (error = nfsrv_access(vp, VEXEC, cred, rdonly, nfsd->nd_procp)) { 1550 vput(vp); 1551 nfsm_reply(0); 1552 } 1553 VOP_UNLOCK(vp); 1554 MALLOC(rbuf, caddr_t, siz, M_TEMP, M_WAITOK); 1555 again: 1556 iv.iov_base = rbuf; 1557 iv.iov_len = fullsiz; 1558 io.uio_iov = &iv; 1559 io.uio_iovcnt = 1; 1560 io.uio_offset = (off_t)off; 1561 io.uio_resid = fullsiz; 1562 io.uio_segflg = UIO_SYSSPACE; 1563 io.uio_rw = UIO_READ; 1564 io.uio_procp = (struct proc *)0; 1565 error = VOP_READDIR(vp, &io, cred); 1566 off = (u_long)io.uio_offset; 1567 if (error) { 1568 vrele(vp); 1569 free((caddr_t)rbuf, M_TEMP); 1570 nfsm_reply(0); 1571 } 1572 if (io.uio_resid < fullsiz) 1573 eofflag = 0; 1574 else 1575 eofflag = 1; 1576 if (io.uio_resid) { 1577 siz -= io.uio_resid; 1578 1579 /* 1580 * If nothing read, return eof 1581 * rpc reply 1582 */ 1583 if (siz == 0) { 1584 vrele(vp); 1585 nfsm_reply(2 * NFSX_UNSIGNED); 1586 nfsm_build(tl, u_long *, 2 * NFSX_UNSIGNED); 1587 *tl++ = nfs_false; 1588 *tl = nfs_true; 1589 FREE((caddr_t)rbuf, M_TEMP); 1590 return (0); 1591 } 1592 } 1593 1594 /* 1595 * Check for degenerate cases of nothing useful read. 1596 * If so go try again 1597 */ 1598 cpos = rbuf + on; 1599 cend = rbuf + siz; 1600 dp = (struct dirent *)cpos; 1601 while (cpos < cend && dp->d_fileno == 0) { 1602 cpos += dp->d_reclen; 1603 dp = (struct dirent *)cpos; 1604 } 1605 if (cpos >= cend) { 1606 toff = off; 1607 siz = fullsiz; 1608 on = 0; 1609 goto again; 1610 } 1611 1612 cpos = rbuf + on; 1613 cend = rbuf + siz; 1614 dp = (struct dirent *)cpos; 1615 len = 3 * NFSX_UNSIGNED; /* paranoia, probably can be 0 */ 1616 nfsm_reply(siz); 1617 mp = mp2 = mb; 1618 bp = bpos; 1619 be = bp + M_TRAILINGSPACE(mp); 1620 1621 /* Loop through the records and build reply */ 1622 while (cpos < cend) { 1623 if (dp->d_fileno != 0) { 1624 nlen = dp->d_namlen; 1625 rem = nfsm_rndup(nlen)-nlen; 1626 1627 /* 1628 * For readdir_and_lookup get the vnode using 1629 * the file number. 1630 */ 1631 if (VFS_VGET(vp->v_mount, dp->d_fileno, &nvp)) 1632 goto invalid; 1633 bzero((caddr_t)&fl.fl_nfh, sizeof (nfsv2fh_t)); 1634 fl.fl_nfh.fh_generic.fh_fsid = 1635 nvp->v_mount->mnt_stat.f_fsid; 1636 if (VFS_VPTOFH(nvp, &fl.fl_nfh.fh_generic.fh_fid)) { 1637 vput(nvp); 1638 goto invalid; 1639 } 1640 if (duration2) { 1641 (void) nqsrv_getlease(nvp, &duration2, NQL_READ, 1642 nfsd, nam, &cache2, &frev2, cred); 1643 fl.fl_duration = txdr_unsigned(duration2); 1644 fl.fl_cachable = txdr_unsigned(cache2); 1645 txdr_hyper(&frev2, fl.fl_frev); 1646 } else 1647 fl.fl_duration = 0; 1648 if (VOP_GETATTR(nvp, vap, cred, nfsd->nd_procp)) { 1649 vput(nvp); 1650 goto invalid; 1651 } 1652 vput(nvp); 1653 fp = (struct nfsv2_fattr *)&fl.fl_fattr; 1654 nfsm_srvfillattr; 1655 len += (4*NFSX_UNSIGNED + nlen + rem + NFSX_FH 1656 + NFSX_NQFATTR); 1657 if (len > cnt) { 1658 eofflag = 0; 1659 break; 1660 } 1661 /* 1662 * Build the directory record xdr from 1663 * the dirent entry. 1664 */ 1665 nfsm_clget; 1666 *tl = nfs_true; 1667 bp += NFSX_UNSIGNED; 1668 1669 /* 1670 * For readdir_and_lookup copy the stuff out. 1671 */ 1672 xfer = sizeof (struct flrep); 1673 cp = (caddr_t)&fl; 1674 while (xfer > 0) { 1675 nfsm_clget; 1676 if ((bp+xfer) > be) 1677 tsiz = be-bp; 1678 else 1679 tsiz = xfer; 1680 bcopy(cp, bp, tsiz); 1681 bp += tsiz; 1682 xfer -= tsiz; 1683 if (xfer > 0) 1684 cp += tsiz; 1685 } 1686 nfsm_clget; 1687 *tl = txdr_unsigned(dp->d_fileno); 1688 bp += NFSX_UNSIGNED; 1689 nfsm_clget; 1690 *tl = txdr_unsigned(nlen); 1691 bp += NFSX_UNSIGNED; 1692 1693 /* And loop around copying the name */ 1694 xfer = nlen; 1695 cp = dp->d_name; 1696 while (xfer > 0) { 1697 nfsm_clget; 1698 if ((bp+xfer) > be) 1699 tsiz = be-bp; 1700 else 1701 tsiz = xfer; 1702 bcopy(cp, bp, tsiz); 1703 bp += tsiz; 1704 xfer -= tsiz; 1705 if (xfer > 0) 1706 cp += tsiz; 1707 } 1708 /* And null pad to a long boundary */ 1709 for (i = 0; i < rem; i++) 1710 *bp++ = '\0'; 1711 nfsm_clget; 1712 1713 /* Finish off the record */ 1714 toff += dp->d_reclen; 1715 *tl = txdr_unsigned(toff); 1716 bp += NFSX_UNSIGNED; 1717 } else 1718 invalid: 1719 toff += dp->d_reclen; 1720 cpos += dp->d_reclen; 1721 dp = (struct dirent *)cpos; 1722 } 1723 vrele(vp); 1724 nfsm_clget; 1725 *tl = nfs_false; 1726 bp += NFSX_UNSIGNED; 1727 nfsm_clget; 1728 if (eofflag) 1729 *tl = nfs_true; 1730 else 1731 *tl = nfs_false; 1732 bp += NFSX_UNSIGNED; 1733 if (mp != mb) { 1734 if (bp < be) 1735 mp->m_len = bp - mtod(mp, caddr_t); 1736 } else 1737 mp->m_len += bp - bpos; 1738 FREE(rbuf, M_TEMP); 1739 nfsm_srvdone; 1740 } 1741 1742 /* 1743 * nfs statfs service 1744 */ 1745 nfsrv_statfs(nfsd, mrep, md, dpos, cred, nam, mrq) 1746 struct nfsd *nfsd; 1747 struct mbuf *mrep, *md; 1748 caddr_t dpos; 1749 struct ucred *cred; 1750 struct mbuf *nam, **mrq; 1751 { 1752 register struct statfs *sf; 1753 register struct nfsv2_statfs *sfp; 1754 register u_long *tl; 1755 register long t1; 1756 caddr_t bpos; 1757 int error = 0, rdonly, cache, isnq; 1758 char *cp2; 1759 struct mbuf *mb, *mb2, *mreq; 1760 struct vnode *vp; 1761 nfsv2fh_t nfh; 1762 fhandle_t *fhp; 1763 struct statfs statfs; 1764 u_quad_t frev; 1765 1766 fhp = &nfh.fh_generic; 1767 isnq = (nfsd->nd_nqlflag != NQL_NOVAL); 1768 nfsm_srvmtofh(fhp); 1769 if (error = nfsrv_fhtovp(fhp, TRUE, &vp, cred, nfsd->nd_slp, nam, &rdonly)) 1770 nfsm_reply(0); 1771 sf = &statfs; 1772 error = VFS_STATFS(vp->v_mount, sf, nfsd->nd_procp); 1773 vput(vp); 1774 nfsm_reply(NFSX_STATFS(isnq)); 1775 nfsm_build(sfp, struct nfsv2_statfs *, NFSX_STATFS(isnq)); 1776 sfp->sf_tsize = txdr_unsigned(NFS_MAXDGRAMDATA); 1777 sfp->sf_bsize = txdr_unsigned(sf->f_bsize); 1778 sfp->sf_blocks = txdr_unsigned(sf->f_blocks); 1779 sfp->sf_bfree = txdr_unsigned(sf->f_bfree); 1780 sfp->sf_bavail = txdr_unsigned(sf->f_bavail); 1781 if (isnq) { 1782 sfp->sf_files = txdr_unsigned(sf->f_files); 1783 sfp->sf_ffree = txdr_unsigned(sf->f_ffree); 1784 } 1785 nfsm_srvdone; 1786 } 1787 1788 /* 1789 * Null operation, used by clients to ping server 1790 */ 1791 /* ARGSUSED */ 1792 nfsrv_null(nfsd, mrep, md, dpos, cred, nam, mrq) 1793 struct nfsd *nfsd; 1794 struct mbuf *mrep, *md; 1795 caddr_t dpos; 1796 struct ucred *cred; 1797 struct mbuf *nam, **mrq; 1798 { 1799 caddr_t bpos; 1800 int error = VNOVAL, cache; 1801 struct mbuf *mb, *mreq; 1802 u_quad_t frev; 1803 1804 nfsm_reply(0); 1805 return (error); 1806 } 1807 1808 /* 1809 * No operation, used for obsolete procedures 1810 */ 1811 /* ARGSUSED */ 1812 nfsrv_noop(nfsd, mrep, md, dpos, cred, nam, mrq) 1813 struct nfsd *nfsd; 1814 struct mbuf *mrep, *md; 1815 caddr_t dpos; 1816 struct ucred *cred; 1817 struct mbuf *nam, **mrq; 1818 { 1819 caddr_t bpos; 1820 int error, cache; 1821 struct mbuf *mb, *mreq; 1822 u_quad_t frev; 1823 1824 if (nfsd->nd_repstat) 1825 error = nfsd->nd_repstat; 1826 else 1827 error = EPROCUNAVAIL; 1828 nfsm_reply(0); 1829 return (error); 1830 } 1831 1832 /* 1833 * Perform access checking for vnodes obtained from file handles that would 1834 * refer to files already opened by a Unix client. You cannot just use 1835 * vn_writechk() and VOP_ACCESS() for two reasons. 1836 * 1 - You must check for exported rdonly as well as MNT_RDONLY for the write case 1837 * 2 - The owner is to be given access irrespective of mode bits so that 1838 * processes that chmod after opening a file don't break. I don't like 1839 * this because it opens a security hole, but since the nfs server opens 1840 * a security hole the size of a barn door anyhow, what the heck. 1841 */ 1842 nfsrv_access(vp, flags, cred, rdonly, p) 1843 register struct vnode *vp; 1844 int flags; 1845 register struct ucred *cred; 1846 int rdonly; 1847 struct proc *p; 1848 { 1849 struct vattr vattr; 1850 int error; 1851 if (flags & VWRITE) { 1852 /* Just vn_writechk() changed to check rdonly */ 1853 /* 1854 * Disallow write attempts on read-only file systems; 1855 * unless the file is a socket or a block or character 1856 * device resident on the file system. 1857 */ 1858 if (rdonly || (vp->v_mount->mnt_flag & MNT_RDONLY)) { 1859 switch (vp->v_type) { 1860 case VREG: case VDIR: case VLNK: 1861 return (EROFS); 1862 } 1863 } 1864 /* 1865 * If there's shared text associated with 1866 * the inode, try to free it up once. If 1867 * we fail, we can't allow writing. 1868 */ 1869 if ((vp->v_flag & VTEXT) && !vnode_pager_uncache(vp)) 1870 return (ETXTBSY); 1871 } 1872 if (error = VOP_GETATTR(vp, &vattr, cred, p)) 1873 return (error); 1874 if ((error = VOP_ACCESS(vp, flags, cred, p)) && 1875 cred->cr_uid != vattr.va_uid) 1876 return (error); 1877 return (0); 1878 } 1879