sys/nfs/nfs_subs.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  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  * 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. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)nfs_subs.c  8.8 (Berkeley) 5/22/95
  37  * $FreeBSD$
  38  */
  39
  40 /*
  41  * These functions support the macros and help fiddle mbuf chains for
  42  * the nfs op functions. They do things like create the rpc header and
  43  * copy data between mbuf chains and uio lists.
  44  */
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/kernel.h>
  48 #include <sys/bio.h>
  49 #include <sys/buf.h>
  50 #include <sys/proc.h>
  51 #include <sys/mount.h>
  52 #include <sys/vnode.h>
  53 #include <sys/namei.h>
  54 #include <sys/mbuf.h>
  55 #include <sys/socket.h>
  56 #include <sys/stat.h>
  57 #include <sys/malloc.h>
  58 #include <sys/sysent.h>
  59 #include <sys/syscall.h>
  60
  61 #include <vm/vm.h>
  62 #include <vm/vm_object.h>
  63 #include <vm/vm_extern.h>
  64 #include <vm/vm_zone.h>
  65
  66 #include <nfs/rpcv2.h>
  67 #include <nfs/nfsproto.h>
  68 #include <nfs/nfs.h>
  69 #include <nfs/nfsnode.h>
  70 #include <nfs/xdr_subs.h>
  71 #include <nfs/nfsm_subs.h>
  72 #include <nfs/nfsmount.h>
  73 #include <nfs/nqnfs.h>
  74 #include <nfs/nfsrtt.h>
  75
  76 #include <netinet/in.h>
  77
  78 /*
  79  * Data items converted to xdr at startup, since they are constant
  80  * This is kinda hokey, but may save a little time doing byte swaps
  81  */
  82 u_int32_t nfs_xdrneg1;
  83 u_int32_t rpc_call, rpc_vers, rpc_reply, rpc_msgdenied, rpc_autherr,
  84         rpc_mismatch, rpc_auth_unix, rpc_msgaccepted,
  85         rpc_auth_kerb;
  86 u_int32_t nfs_prog, nqnfs_prog, nfs_true, nfs_false;
  87
  88 /* And other global data */
  89 static u_int32_t nfs_xid = 0;
  90 static enum vtype nv2tov_type[8]= {
  91         VNON, VREG, VDIR, VBLK, VCHR, VLNK, VNON,  VNON
  92 };
  93 enum vtype nv3tov_type[8]= {
  94         VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO
  95 };
  96
  97 int nfs_ticks;
  98 int nfs_pbuf_freecnt = -1;      /* start out unlimited */
  99
 100 struct nfs_reqq nfs_reqq;
 101 struct nfssvc_sockhead nfssvc_sockhead;
 102 int nfssvc_sockhead_flag;
 103 struct nfsd_head nfsd_head;
 104 int nfsd_head_flag;
 105 struct nfs_bufq nfs_bufq;
 106 struct nqtimerhead nqtimerhead;
 107 struct nqfhhashhead *nqfhhashtbl;
 108 u_long nqfhhash;
 109
 110 static void (*nfs_prev_lease_updatetime) __P((int));
 111 static int nfs_prev_nfssvc_sy_narg;
 112 static sy_call_t *nfs_prev_nfssvc_sy_call;
 113
 114 #ifndef NFS_NOSERVER
 115
 116 static vop_t *nfs_prev_vop_lease_check;
 117
 118 /*
 119  * Mapping of old NFS Version 2 RPC numbers to generic numbers.
 120  */
 121 int nfsv3_procid[NFS_NPROCS] = {
 122         NFSPROC_NULL,
 123         NFSPROC_GETATTR,
 124         NFSPROC_SETATTR,
 125         NFSPROC_NOOP,
 126         NFSPROC_LOOKUP,
 127         NFSPROC_READLINK,
 128         NFSPROC_READ,
 129         NFSPROC_NOOP,
 130         NFSPROC_WRITE,
 131         NFSPROC_CREATE,
 132         NFSPROC_REMOVE,
 133         NFSPROC_RENAME,
 134         NFSPROC_LINK,
 135         NFSPROC_SYMLINK,
 136         NFSPROC_MKDIR,
 137         NFSPROC_RMDIR,
 138         NFSPROC_READDIR,
 139         NFSPROC_FSSTAT,
 140         NFSPROC_NOOP,
 141         NFSPROC_NOOP,
 142         NFSPROC_NOOP,
 143         NFSPROC_NOOP,
 144         NFSPROC_NOOP,
 145         NFSPROC_NOOP,
 146         NFSPROC_NOOP,
 147         NFSPROC_NOOP
 148 };
 149
 150 #endif /* NFS_NOSERVER */
 151 /*
 152  * and the reverse mapping from generic to Version 2 procedure numbers
 153  */
 154 int nfsv2_procid[NFS_NPROCS] = {
 155         NFSV2PROC_NULL,
 156         NFSV2PROC_GETATTR,
 157         NFSV2PROC_SETATTR,
 158         NFSV2PROC_LOOKUP,
 159         NFSV2PROC_NOOP,
 160         NFSV2PROC_READLINK,
 161         NFSV2PROC_READ,
 162         NFSV2PROC_WRITE,
 163         NFSV2PROC_CREATE,
 164         NFSV2PROC_MKDIR,
 165         NFSV2PROC_SYMLINK,
 166         NFSV2PROC_CREATE,
 167         NFSV2PROC_REMOVE,
 168         NFSV2PROC_RMDIR,
 169         NFSV2PROC_RENAME,
 170         NFSV2PROC_LINK,
 171         NFSV2PROC_READDIR,
 172         NFSV2PROC_NOOP,
 173         NFSV2PROC_STATFS,
 174         NFSV2PROC_NOOP,
 175         NFSV2PROC_NOOP,
 176         NFSV2PROC_NOOP,
 177         NFSV2PROC_NOOP,
 178         NFSV2PROC_NOOP,
 179         NFSV2PROC_NOOP,
 180         NFSV2PROC_NOOP,
 181 };
 182
 183 #ifndef NFS_NOSERVER
 184 /*
 185  * Maps errno values to nfs error numbers.
 186  * Use NFSERR_IO as the catch all for ones not specifically defined in
 187  * RFC 1094.
 188  */
 189 static u_char nfsrv_v2errmap[ELAST] = {
 190   NFSERR_PERM,  NFSERR_NOENT,   NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 191   NFSERR_NXIO,  NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 192   NFSERR_IO,    NFSERR_IO,      NFSERR_ACCES,   NFSERR_IO,      NFSERR_IO,
 193   NFSERR_IO,    NFSERR_EXIST,   NFSERR_IO,      NFSERR_NODEV,   NFSERR_NOTDIR,
 194   NFSERR_ISDIR, NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 195   NFSERR_IO,    NFSERR_FBIG,    NFSERR_NOSPC,   NFSERR_IO,      NFSERR_ROFS,
 196   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 197   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 198   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 199   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 200   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 201   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 202   NFSERR_IO,    NFSERR_IO,      NFSERR_NAMETOL, NFSERR_IO,      NFSERR_IO,
 203   NFSERR_NOTEMPTY, NFSERR_IO,   NFSERR_IO,      NFSERR_DQUOT,   NFSERR_STALE,
 204   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 205   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 206   NFSERR_IO,    NFSERR_IO,      NFSERR_IO,      NFSERR_IO,      NFSERR_IO,
 207   NFSERR_IO /* << Last is 86 */
 208 };
 209
 210 /*
 211  * Maps errno values to nfs error numbers.
 212  * Although it is not obvious whether or not NFS clients really care if
 213  * a returned error value is in the specified list for the procedure, the
 214  * safest thing to do is filter them appropriately. For Version 2, the
 215  * X/Open XNFS document is the only specification that defines error values
 216  * for each RPC (The RFC simply lists all possible error values for all RPCs),
 217  * so I have decided to not do this for Version 2.
 218  * The first entry is the default error return and the rest are the valid
 219  * errors for that RPC in increasing numeric order.
 220  */
 221 static short nfsv3err_null[] = {
 222         0,
 223         0,
 224 };
 225
 226 static short nfsv3err_getattr[] = {
 227         NFSERR_IO,
 228         NFSERR_IO,
 229         NFSERR_STALE,
 230         NFSERR_BADHANDLE,
 231         NFSERR_SERVERFAULT,
 232         0,
 233 };
 234
 235 static short nfsv3err_setattr[] = {
 236         NFSERR_IO,
 237         NFSERR_PERM,
 238         NFSERR_IO,
 239         NFSERR_ACCES,
 240         NFSERR_INVAL,
 241         NFSERR_NOSPC,
 242         NFSERR_ROFS,
 243         NFSERR_DQUOT,
 244         NFSERR_STALE,
 245         NFSERR_BADHANDLE,
 246         NFSERR_NOT_SYNC,
 247         NFSERR_SERVERFAULT,
 248         0,
 249 };
 250
 251 static short nfsv3err_lookup[] = {
 252         NFSERR_IO,
 253         NFSERR_NOENT,
 254         NFSERR_IO,
 255         NFSERR_ACCES,
 256         NFSERR_NOTDIR,
 257         NFSERR_NAMETOL,
 258         NFSERR_STALE,
 259         NFSERR_BADHANDLE,
 260         NFSERR_SERVERFAULT,
 261         0,
 262 };
 263
 264 static short nfsv3err_access[] = {
 265         NFSERR_IO,
 266         NFSERR_IO,
 267         NFSERR_STALE,
 268         NFSERR_BADHANDLE,
 269         NFSERR_SERVERFAULT,
 270         0,
 271 };
 272
 273 static short nfsv3err_readlink[] = {
 274         NFSERR_IO,
 275         NFSERR_IO,
 276         NFSERR_ACCES,
 277         NFSERR_INVAL,
 278         NFSERR_STALE,
 279         NFSERR_BADHANDLE,
 280         NFSERR_NOTSUPP,
 281         NFSERR_SERVERFAULT,
 282         0,
 283 };
 284
 285 static short nfsv3err_read[] = {
 286         NFSERR_IO,
 287         NFSERR_IO,
 288         NFSERR_NXIO,
 289         NFSERR_ACCES,
 290         NFSERR_INVAL,
 291         NFSERR_STALE,
 292         NFSERR_BADHANDLE,
 293         NFSERR_SERVERFAULT,
 294         0,
 295 };
 296
 297 static short nfsv3err_write[] = {
 298         NFSERR_IO,
 299         NFSERR_IO,
 300         NFSERR_ACCES,
 301         NFSERR_INVAL,
 302         NFSERR_FBIG,
 303         NFSERR_NOSPC,
 304         NFSERR_ROFS,
 305         NFSERR_DQUOT,
 306         NFSERR_STALE,
 307         NFSERR_BADHANDLE,
 308         NFSERR_SERVERFAULT,
 309         0,
 310 };
 311
 312 static short nfsv3err_create[] = {
 313         NFSERR_IO,
 314         NFSERR_IO,
 315         NFSERR_ACCES,
 316         NFSERR_EXIST,
 317         NFSERR_NOTDIR,
 318         NFSERR_NOSPC,
 319         NFSERR_ROFS,
 320         NFSERR_NAMETOL,
 321         NFSERR_DQUOT,
 322         NFSERR_STALE,
 323         NFSERR_BADHANDLE,
 324         NFSERR_NOTSUPP,
 325         NFSERR_SERVERFAULT,
 326         0,
 327 };
 328
 329 static short nfsv3err_mkdir[] = {
 330         NFSERR_IO,
 331         NFSERR_IO,
 332         NFSERR_ACCES,
 333         NFSERR_EXIST,
 334         NFSERR_NOTDIR,
 335         NFSERR_NOSPC,
 336         NFSERR_ROFS,
 337         NFSERR_NAMETOL,
 338         NFSERR_DQUOT,
 339         NFSERR_STALE,
 340         NFSERR_BADHANDLE,
 341         NFSERR_NOTSUPP,
 342         NFSERR_SERVERFAULT,
 343         0,
 344 };
 345
 346 static short nfsv3err_symlink[] = {
 347         NFSERR_IO,
 348         NFSERR_IO,
 349         NFSERR_ACCES,
 350         NFSERR_EXIST,
 351         NFSERR_NOTDIR,
 352         NFSERR_NOSPC,
 353         NFSERR_ROFS,
 354         NFSERR_NAMETOL,
 355         NFSERR_DQUOT,
 356         NFSERR_STALE,
 357         NFSERR_BADHANDLE,
 358         NFSERR_NOTSUPP,
 359         NFSERR_SERVERFAULT,
 360         0,
 361 };
 362
 363 static short nfsv3err_mknod[] = {
 364         NFSERR_IO,
 365         NFSERR_IO,
 366         NFSERR_ACCES,
 367         NFSERR_EXIST,
 368         NFSERR_NOTDIR,
 369         NFSERR_NOSPC,
 370         NFSERR_ROFS,
 371         NFSERR_NAMETOL,
 372         NFSERR_DQUOT,
 373         NFSERR_STALE,
 374         NFSERR_BADHANDLE,
 375         NFSERR_NOTSUPP,
 376         NFSERR_SERVERFAULT,
 377         NFSERR_BADTYPE,
 378         0,
 379 };
 380
 381 static short nfsv3err_remove[] = {
 382         NFSERR_IO,
 383         NFSERR_NOENT,
 384         NFSERR_IO,
 385         NFSERR_ACCES,
 386         NFSERR_NOTDIR,
 387         NFSERR_ROFS,
 388         NFSERR_NAMETOL,
 389         NFSERR_STALE,
 390         NFSERR_BADHANDLE,
 391         NFSERR_SERVERFAULT,
 392         0,
 393 };
 394
 395 static short nfsv3err_rmdir[] = {
 396         NFSERR_IO,
 397         NFSERR_NOENT,
 398         NFSERR_IO,
 399         NFSERR_ACCES,
 400         NFSERR_EXIST,
 401         NFSERR_NOTDIR,
 402         NFSERR_INVAL,
 403         NFSERR_ROFS,
 404         NFSERR_NAMETOL,
 405         NFSERR_NOTEMPTY,
 406         NFSERR_STALE,
 407         NFSERR_BADHANDLE,
 408         NFSERR_NOTSUPP,
 409         NFSERR_SERVERFAULT,
 410         0,
 411 };
 412
 413 static short nfsv3err_rename[] = {
 414         NFSERR_IO,
 415         NFSERR_NOENT,
 416         NFSERR_IO,
 417         NFSERR_ACCES,
 418         NFSERR_EXIST,
 419         NFSERR_XDEV,
 420         NFSERR_NOTDIR,
 421         NFSERR_ISDIR,
 422         NFSERR_INVAL,
 423         NFSERR_NOSPC,
 424         NFSERR_ROFS,
 425         NFSERR_MLINK,
 426         NFSERR_NAMETOL,
 427         NFSERR_NOTEMPTY,
 428         NFSERR_DQUOT,
 429         NFSERR_STALE,
 430         NFSERR_BADHANDLE,
 431         NFSERR_NOTSUPP,
 432         NFSERR_SERVERFAULT,
 433         0,
 434 };
 435
 436 static short nfsv3err_link[] = {
 437         NFSERR_IO,
 438         NFSERR_IO,
 439         NFSERR_ACCES,
 440         NFSERR_EXIST,
 441         NFSERR_XDEV,
 442         NFSERR_NOTDIR,
 443         NFSERR_INVAL,
 444         NFSERR_NOSPC,
 445         NFSERR_ROFS,
 446         NFSERR_MLINK,
 447         NFSERR_NAMETOL,
 448         NFSERR_DQUOT,
 449         NFSERR_STALE,
 450         NFSERR_BADHANDLE,
 451         NFSERR_NOTSUPP,
 452         NFSERR_SERVERFAULT,
 453         0,
 454 };
 455
 456 static short nfsv3err_readdir[] = {
 457         NFSERR_IO,
 458         NFSERR_IO,
 459         NFSERR_ACCES,
 460         NFSERR_NOTDIR,
 461         NFSERR_STALE,
 462         NFSERR_BADHANDLE,
 463         NFSERR_BAD_COOKIE,
 464         NFSERR_TOOSMALL,
 465         NFSERR_SERVERFAULT,
 466         0,
 467 };
 468
 469 static short nfsv3err_readdirplus[] = {
 470         NFSERR_IO,
 471         NFSERR_IO,
 472         NFSERR_ACCES,
 473         NFSERR_NOTDIR,
 474         NFSERR_STALE,
 475         NFSERR_BADHANDLE,
 476         NFSERR_BAD_COOKIE,
 477         NFSERR_NOTSUPP,
 478         NFSERR_TOOSMALL,
 479         NFSERR_SERVERFAULT,
 480         0,
 481 };
 482
 483 static short nfsv3err_fsstat[] = {
 484         NFSERR_IO,
 485         NFSERR_IO,
 486         NFSERR_STALE,
 487         NFSERR_BADHANDLE,
 488         NFSERR_SERVERFAULT,
 489         0,
 490 };
 491
 492 static short nfsv3err_fsinfo[] = {
 493         NFSERR_STALE,
 494         NFSERR_STALE,
 495         NFSERR_BADHANDLE,
 496         NFSERR_SERVERFAULT,
 497         0,
 498 };
 499
 500 static short nfsv3err_pathconf[] = {
 501         NFSERR_STALE,
 502         NFSERR_STALE,
 503         NFSERR_BADHANDLE,
 504         NFSERR_SERVERFAULT,
 505         0,
 506 };
 507
 508 static short nfsv3err_commit[] = {
 509         NFSERR_IO,
 510         NFSERR_IO,
 511         NFSERR_STALE,
 512         NFSERR_BADHANDLE,
 513         NFSERR_SERVERFAULT,
 514         0,
 515 };
 516
 517 static short *nfsrv_v3errmap[] = {
 518         nfsv3err_null,
 519         nfsv3err_getattr,
 520         nfsv3err_setattr,
 521         nfsv3err_lookup,
 522         nfsv3err_access,
 523         nfsv3err_readlink,
 524         nfsv3err_read,
 525         nfsv3err_write,
 526         nfsv3err_create,
 527         nfsv3err_mkdir,
 528         nfsv3err_symlink,
 529         nfsv3err_mknod,
 530         nfsv3err_remove,
 531         nfsv3err_rmdir,
 532         nfsv3err_rename,
 533         nfsv3err_link,
 534         nfsv3err_readdir,
 535         nfsv3err_readdirplus,
 536         nfsv3err_fsstat,
 537         nfsv3err_fsinfo,
 538         nfsv3err_pathconf,
 539         nfsv3err_commit,
 540 };
 541
 542 #endif /* NFS_NOSERVER */
 543
 544 extern struct nfsrtt nfsrtt;
 545 extern time_t nqnfsstarttime;
 546 extern int nqsrv_clockskew;
 547 extern int nqsrv_writeslack;
 548 extern int nqsrv_maxlease;
 549 extern struct nfsstats nfsstats;
 550 extern int nqnfs_piggy[NFS_NPROCS];
 551 extern nfstype nfsv2_type[9];
 552 extern nfstype nfsv3_type[9];
 553 extern struct nfsnodehashhead *nfsnodehashtbl;
 554 extern u_long nfsnodehash;
 555
 556 struct nfssvc_args;
 557 extern int nfssvc(struct proc *, struct nfssvc_args *, int *);
 558
 559 LIST_HEAD(nfsnodehashhead, nfsnode);
 560
 561 int nfs_webnamei __P((struct nameidata *, struct vnode *, struct proc *));
 562
 563 u_quad_t
 564 nfs_curusec()
 565 {
 566         struct timeval tv;
 567
 568         getmicrotime(&tv);
 569         return ((u_quad_t)tv.tv_sec * 1000000 + (u_quad_t)tv.tv_usec);
 570 }
 571
 572 /*
 573  * Create the header for an rpc request packet
 574  * The hsiz is the size of the rest of the nfs request header.
 575  * (just used to decide if a cluster is a good idea)
 576  */
 577 struct mbuf *
 578 nfsm_reqh(vp, procid, hsiz, bposp)
 579         struct vnode *vp;
 580         u_long procid;
 581         int hsiz;
 582         caddr_t *bposp;
 583 {
 584         register struct mbuf *mb;
 585         register u_int32_t *tl;
 586         register caddr_t bpos;
 587         struct mbuf *mb2;
 588         struct nfsmount *nmp;
 589         int nqflag;
 590
 591         MGET(mb, M_TRYWAIT, MT_DATA);
 592         if (hsiz >= MINCLSIZE)
 593                 MCLGET(mb, M_TRYWAIT);
 594         mb->m_len = 0;
 595         bpos = mtod(mb, caddr_t);
 596
 597         /*
 598          * For NQNFS, add lease request.
 599          */
 600         if (vp) {
 601                 nmp = VFSTONFS(vp->v_mount);
 602                 if (nmp->nm_flag & NFSMNT_NQNFS) {
 603                         nqflag = NQNFS_NEEDLEASE(vp, procid);
 604                         if (nqflag) {
 605                                 nfsm_build(tl, u_int32_t *, 2*NFSX_UNSIGNED);
 606                                 *tl++ = txdr_unsigned(nqflag);
 607                                 *tl = txdr_unsigned(nmp->nm_leaseterm);
 608                         } else {
 609                                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
 610                                 *tl = 0;
 611                         }
 612                 }
 613         }
 614         /* Finally, return values */
 615         *bposp = bpos;
 616         return (mb);
 617 }
 618
 619 /*
 620  * Build the RPC header and fill in the authorization info.
 621  * The authorization string argument is only used when the credentials
 622  * come from outside of the kernel.
 623  * Returns the head of the mbuf list.
 624  */
 625 struct mbuf *
 626 nfsm_rpchead(cr, nmflag, procid, auth_type, auth_len, auth_str, verf_len,
 627         verf_str, mrest, mrest_len, mbp, xidp)
 628         register struct ucred *cr;
 629         int nmflag;
 630         int procid;
 631         int auth_type;
 632         int auth_len;
 633         char *auth_str;
 634         int verf_len;
 635         char *verf_str;
 636         struct mbuf *mrest;
 637         int mrest_len;
 638         struct mbuf **mbp;
 639         u_int32_t *xidp;
 640 {
 641         register struct mbuf *mb;
 642         register u_int32_t *tl;
 643         register caddr_t bpos;
 644         register int i;
 645         struct mbuf *mreq, *mb2;
 646         int siz, grpsiz, authsiz;
 647
 648         authsiz = nfsm_rndup(auth_len);
 649         MGETHDR(mb, M_TRYWAIT, MT_DATA);
 650         if ((authsiz + 10 * NFSX_UNSIGNED) >= MINCLSIZE) {
 651                 MCLGET(mb, M_TRYWAIT);
 652         } else if ((authsiz + 10 * NFSX_UNSIGNED) < MHLEN) {
 653                 MH_ALIGN(mb, authsiz + 10 * NFSX_UNSIGNED);
 654         } else {
 655                 MH_ALIGN(mb, 8 * NFSX_UNSIGNED);
 656         }
 657         mb->m_len = 0;
 658         mreq = mb;
 659         bpos = mtod(mb, caddr_t);
 660
 661         /*
 662          * First the RPC header.
 663          */
 664         nfsm_build(tl, u_int32_t *, 8 * NFSX_UNSIGNED);
 665
 666         /* Get a pretty random xid to start with */
 667         if (!nfs_xid)
 668                 nfs_xid = random();
 669         /*
 670          * Skip zero xid if it should ever happen.
 671          */
 672         if (++nfs_xid == 0)
 673                 nfs_xid++;
 674
 675         *tl++ = *xidp = txdr_unsigned(nfs_xid);
 676         *tl++ = rpc_call;
 677         *tl++ = rpc_vers;
 678         if (nmflag & NFSMNT_NQNFS) {
 679                 *tl++ = txdr_unsigned(NQNFS_PROG);
 680                 *tl++ = txdr_unsigned(NQNFS_VER3);
 681         } else {
 682                 *tl++ = txdr_unsigned(NFS_PROG);
 683                 if (nmflag & NFSMNT_NFSV3)
 684                         *tl++ = txdr_unsigned(NFS_VER3);
 685                 else
 686                         *tl++ = txdr_unsigned(NFS_VER2);
 687         }
 688         if (nmflag & NFSMNT_NFSV3)
 689                 *tl++ = txdr_unsigned(procid);
 690         else
 691                 *tl++ = txdr_unsigned(nfsv2_procid[procid]);
 692
 693         /*
 694          * And then the authorization cred.
 695          */
 696         *tl++ = txdr_unsigned(auth_type);
 697         *tl = txdr_unsigned(authsiz);
 698         switch (auth_type) {
 699         case RPCAUTH_UNIX:
 700                 nfsm_build(tl, u_int32_t *, auth_len);
 701                 *tl++ = 0;              /* stamp ?? */
 702                 *tl++ = 0;              /* NULL hostname */
 703                 *tl++ = txdr_unsigned(cr->cr_uid);
 704                 *tl++ = txdr_unsigned(cr->cr_groups[0]);
 705                 grpsiz = (auth_len >> 2) - 5;
 706                 *tl++ = txdr_unsigned(grpsiz);
 707                 for (i = 1; i <= grpsiz; i++)
 708                         *tl++ = txdr_unsigned(cr->cr_groups[i]);
 709                 break;
 710         case RPCAUTH_KERB4:
 711                 siz = auth_len;
 712                 while (siz > 0) {
 713                         if (M_TRAILINGSPACE(mb) == 0) {
 714                                 MGET(mb2, M_TRYWAIT, MT_DATA);
 715                                 if (siz >= MINCLSIZE)
 716                                         MCLGET(mb2, M_TRYWAIT);
 717                                 mb->m_next = mb2;
 718                                 mb = mb2;
 719                                 mb->m_len = 0;
 720                                 bpos = mtod(mb, caddr_t);
 721                         }
 722                         i = min(siz, M_TRAILINGSPACE(mb));
 723                         bcopy(auth_str, bpos, i);
 724                         mb->m_len += i;
 725                         auth_str += i;
 726                         bpos += i;
 727                         siz -= i;
 728                 }
 729                 if ((siz = (nfsm_rndup(auth_len) - auth_len)) > 0) {
 730                         for (i = 0; i < siz; i++)
 731                                 *bpos++ = '\0';
 732                         mb->m_len += siz;
 733                 }
 734                 break;
 735         };
 736
 737         /*
 738          * And the verifier...
 739          */
 740         nfsm_build(tl, u_int32_t *, 2 * NFSX_UNSIGNED);
 741         if (verf_str) {
 742                 *tl++ = txdr_unsigned(RPCAUTH_KERB4);
 743                 *tl = txdr_unsigned(verf_len);
 744                 siz = verf_len;
 745                 while (siz > 0) {
 746                         if (M_TRAILINGSPACE(mb) == 0) {
 747                                 MGET(mb2, M_TRYWAIT, MT_DATA);
 748                                 if (siz >= MINCLSIZE)
 749                                         MCLGET(mb2, M_TRYWAIT);
 750                                 mb->m_next = mb2;
 751                                 mb = mb2;
 752                                 mb->m_len = 0;
 753                                 bpos = mtod(mb, caddr_t);
 754                         }
 755                         i = min(siz, M_TRAILINGSPACE(mb));
 756                         bcopy(verf_str, bpos, i);
 757                         mb->m_len += i;
 758                         verf_str += i;
 759                         bpos += i;
 760                         siz -= i;
 761                 }
 762                 if ((siz = (nfsm_rndup(verf_len) - verf_len)) > 0) {
 763                         for (i = 0; i < siz; i++)
 764                                 *bpos++ = '\0';
 765                         mb->m_len += siz;
 766                 }
 767         } else {
 768                 *tl++ = txdr_unsigned(RPCAUTH_NULL);
 769                 *tl = 0;
 770         }
 771         mb->m_next = mrest;
 772         mreq->m_pkthdr.len = authsiz + 10 * NFSX_UNSIGNED + mrest_len;
 773         mreq->m_pkthdr.rcvif = (struct ifnet *)0;
 774         *mbp = mb;
 775         return (mreq);
 776 }
 777
 778 /*
 779  * copies mbuf chain to the uio scatter/gather list
 780  */
 781 int
 782 nfsm_mbuftouio(mrep, uiop, siz, dpos)
 783         struct mbuf **mrep;
 784         register struct uio *uiop;
 785         int siz;
 786         caddr_t *dpos;
 787 {
 788         register char *mbufcp, *uiocp;
 789         register int xfer, left, len;
 790         register struct mbuf *mp;
 791         long uiosiz, rem;
 792         int error = 0;
 793
 794         mp = *mrep;
 795         mbufcp = *dpos;
 796         len = mtod(mp, caddr_t)+mp->m_len-mbufcp;
 797         rem = nfsm_rndup(siz)-siz;
 798         while (siz > 0) {
 799                 if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
 800                         return (EFBIG);
 801                 left = uiop->uio_iov->iov_len;
 802                 uiocp = uiop->uio_iov->iov_base;
 803                 if (left > siz)
 804                         left = siz;
 805                 uiosiz = left;
 806                 while (left > 0) {
 807                         while (len == 0) {
 808                                 mp = mp->m_next;
 809                                 if (mp == NULL)
 810                                         return (EBADRPC);
 811                                 mbufcp = mtod(mp, caddr_t);
 812                                 len = mp->m_len;
 813                         }
 814                         xfer = (left > len) ? len : left;
 815 #ifdef notdef
 816                         /* Not Yet.. */
 817                         if (uiop->uio_iov->iov_op != NULL)
 818                                 (*(uiop->uio_iov->iov_op))
 819                                 (mbufcp, uiocp, xfer);
 820                         else
 821 #endif
 822                         if (uiop->uio_segflg == UIO_SYSSPACE)
 823                                 bcopy(mbufcp, uiocp, xfer);
 824                         else
 825                                 copyout(mbufcp, uiocp, xfer);
 826                         left -= xfer;
 827                         len -= xfer;
 828                         mbufcp += xfer;
 829                         uiocp += xfer;
 830                         uiop->uio_offset += xfer;
 831                         uiop->uio_resid -= xfer;
 832                 }
 833                 if (uiop->uio_iov->iov_len <= siz) {
 834                         uiop->uio_iovcnt--;
 835                         uiop->uio_iov++;
 836                 } else {
 837                         uiop->uio_iov->iov_base += uiosiz;
 838                         uiop->uio_iov->iov_len -= uiosiz;
 839                 }
 840                 siz -= uiosiz;
 841         }
 842         *dpos = mbufcp;
 843         *mrep = mp;
 844         if (rem > 0) {
 845                 if (len < rem)
 846                         error = nfs_adv(mrep, dpos, rem, len);
 847                 else
 848                         *dpos += rem;
 849         }
 850         return (error);
 851 }
 852
 853 /*
 854  * copies a uio scatter/gather list to an mbuf chain.
 855  * NOTE: can ony handle iovcnt == 1
 856  */
 857 int
 858 nfsm_uiotombuf(uiop, mq, siz, bpos)
 859         register struct uio *uiop;
 860         struct mbuf **mq;
 861         int siz;
 862         caddr_t *bpos;
 863 {
 864         register char *uiocp;
 865         register struct mbuf *mp, *mp2;
 866         register int xfer, left, mlen;
 867         int uiosiz, clflg, rem;
 868         char *cp;
 869
 870 #ifdef DIAGNOSTIC
 871         if (uiop->uio_iovcnt != 1)
 872                 panic("nfsm_uiotombuf: iovcnt != 1");
 873 #endif
 874
 875         if (siz > MLEN)         /* or should it >= MCLBYTES ?? */
 876                 clflg = 1;
 877         else
 878                 clflg = 0;
 879         rem = nfsm_rndup(siz)-siz;
 880         mp = mp2 = *mq;
 881         while (siz > 0) {
 882                 left = uiop->uio_iov->iov_len;
 883                 uiocp = uiop->uio_iov->iov_base;
 884                 if (left > siz)
 885                         left = siz;
 886                 uiosiz = left;
 887                 while (left > 0) {
 888                         mlen = M_TRAILINGSPACE(mp);
 889                         if (mlen == 0) {
 890                                 MGET(mp, M_TRYWAIT, MT_DATA);
 891                                 if (clflg)
 892                                         MCLGET(mp, M_TRYWAIT);
 893                                 mp->m_len = 0;
 894                                 mp2->m_next = mp;
 895                                 mp2 = mp;
 896                                 mlen = M_TRAILINGSPACE(mp);
 897                         }
 898                         xfer = (left > mlen) ? mlen : left;
 899 #ifdef notdef
 900                         /* Not Yet.. */
 901                         if (uiop->uio_iov->iov_op != NULL)
 902                                 (*(uiop->uio_iov->iov_op))
 903                                 (uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
 904                         else
 905 #endif
 906                         if (uiop->uio_segflg == UIO_SYSSPACE)
 907                                 bcopy(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
 908                         else
 909                                 copyin(uiocp, mtod(mp, caddr_t)+mp->m_len, xfer);
 910                         mp->m_len += xfer;
 911                         left -= xfer;
 912                         uiocp += xfer;
 913                         uiop->uio_offset += xfer;
 914                         uiop->uio_resid -= xfer;
 915                 }
 916                 uiop->uio_iov->iov_base += uiosiz;
 917                 uiop->uio_iov->iov_len -= uiosiz;
 918                 siz -= uiosiz;
 919         }
 920         if (rem > 0) {
 921                 if (rem > M_TRAILINGSPACE(mp)) {
 922                         MGET(mp, M_TRYWAIT, MT_DATA);
 923                         mp->m_len = 0;
 924                         mp2->m_next = mp;
 925                 }
 926                 cp = mtod(mp, caddr_t)+mp->m_len;
 927                 for (left = 0; left < rem; left++)
 928                         *cp++ = '\0';
 929                 mp->m_len += rem;
 930                 *bpos = cp;
 931         } else
 932                 *bpos = mtod(mp, caddr_t)+mp->m_len;
 933         *mq = mp;
 934         return (0);
 935 }
 936
 937 /*
 938  * Help break down an mbuf chain by setting the first siz bytes contiguous
 939  * pointed to by returned val.
 940  * This is used by the macros nfsm_dissect and nfsm_dissecton for tough
 941  * cases. (The macros use the vars. dpos and dpos2)
 942  */
 943 int
 944 nfsm_disct(mdp, dposp, siz, left, cp2)
 945         struct mbuf **mdp;
 946         caddr_t *dposp;
 947         int siz;
 948         int left;
 949         caddr_t *cp2;
 950 {
 951         register struct mbuf *mp, *mp2;
 952         register int siz2, xfer;
 953         register caddr_t p;
 954
 955         mp = *mdp;
 956         while (left == 0) {
 957                 *mdp = mp = mp->m_next;
 958                 if (mp == NULL)
 959                         return (EBADRPC);
 960                 left = mp->m_len;
 961                 *dposp = mtod(mp, caddr_t);
 962         }
 963         if (left >= siz) {
 964                 *cp2 = *dposp;
 965                 *dposp += siz;
 966         } else if (mp->m_next == NULL) {
 967                 return (EBADRPC);
 968         } else if (siz > MHLEN) {
 969                 panic("nfs S too big");
 970         } else {
 971                 MGET(mp2, M_TRYWAIT, MT_DATA);
 972                 mp2->m_next = mp->m_next;
 973                 mp->m_next = mp2;
 974                 mp->m_len -= left;
 975                 mp = mp2;
 976                 *cp2 = p = mtod(mp, caddr_t);
 977                 bcopy(*dposp, p, left);         /* Copy what was left */
 978                 siz2 = siz-left;
 979                 p += left;
 980                 mp2 = mp->m_next;
 981                 /* Loop around copying up the siz2 bytes */
 982                 while (siz2 > 0) {
 983                         if (mp2 == NULL)
 984                                 return (EBADRPC);
 985                         xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
 986                         if (xfer > 0) {
 987                                 bcopy(mtod(mp2, caddr_t), p, xfer);
 988                                 NFSMADV(mp2, xfer);
 989                                 mp2->m_len -= xfer;
 990                                 p += xfer;
 991                                 siz2 -= xfer;
 992                         }
 993                         if (siz2 > 0)
 994                                 mp2 = mp2->m_next;
 995                 }
 996                 mp->m_len = siz;
 997                 *mdp = mp2;
 998                 *dposp = mtod(mp2, caddr_t);
 999         }
1000         return (0);
1001 }
1002
1003 /*
1004  * Advance the position in the mbuf chain.
1005  */
1006 int
1007 nfs_adv(mdp, dposp, offs, left)
1008         struct mbuf **mdp;
1009         caddr_t *dposp;
1010         int offs;
1011         int left;
1012 {
1013         register struct mbuf *m;
1014         register int s;
1015
1016         m = *mdp;
1017         s = left;
1018         while (s < offs) {
1019                 offs -= s;
1020                 m = m->m_next;
1021                 if (m == NULL)
1022                         return (EBADRPC);
1023                 s = m->m_len;
1024         }
1025         *mdp = m;
1026         *dposp = mtod(m, caddr_t)+offs;
1027         return (0);
1028 }
1029
1030 /*
1031  * Copy a string into mbufs for the hard cases...
1032  */
1033 int
1034 nfsm_strtmbuf(mb, bpos, cp, siz)
1035         struct mbuf **mb;
1036         char **bpos;
1037         const char *cp;
1038         long siz;
1039 {
1040         register struct mbuf *m1 = NULL, *m2;
1041         long left, xfer, len, tlen;
1042         u_int32_t *tl;
1043         int putsize;
1044
1045         putsize = 1;
1046         m2 = *mb;
1047         left = M_TRAILINGSPACE(m2);
1048         if (left > 0) {
1049                 tl = ((u_int32_t *)(*bpos));
1050                 *tl++ = txdr_unsigned(siz);
1051                 putsize = 0;
1052                 left -= NFSX_UNSIGNED;
1053                 m2->m_len += NFSX_UNSIGNED;
1054                 if (left > 0) {
1055                         bcopy(cp, (caddr_t) tl, left);
1056                         siz -= left;
1057                         cp += left;
1058                         m2->m_len += left;
1059                         left = 0;
1060                 }
1061         }
1062         /* Loop around adding mbufs */
1063         while (siz > 0) {
1064                 MGET(m1, M_TRYWAIT, MT_DATA);
1065                 if (siz > MLEN)
1066                         MCLGET(m1, M_TRYWAIT);
1067                 m1->m_len = NFSMSIZ(m1);
1068                 m2->m_next = m1;
1069                 m2 = m1;
1070                 tl = mtod(m1, u_int32_t *);
1071                 tlen = 0;
1072                 if (putsize) {
1073                         *tl++ = txdr_unsigned(siz);
1074                         m1->m_len -= NFSX_UNSIGNED;
1075                         tlen = NFSX_UNSIGNED;
1076                         putsize = 0;
1077                 }
1078                 if (siz < m1->m_len) {
1079                         len = nfsm_rndup(siz);
1080                         xfer = siz;
1081                         if (xfer < len)
1082                                 *(tl+(xfer>>2)) = 0;
1083                 } else {
1084                         xfer = len = m1->m_len;
1085                 }
1086                 bcopy(cp, (caddr_t) tl, xfer);
1087                 m1->m_len = len+tlen;
1088                 siz -= xfer;
1089                 cp += xfer;
1090         }
1091         *mb = m1;
1092         *bpos = mtod(m1, caddr_t)+m1->m_len;
1093         return (0);
1094 }
1095
1096 /*
1097  * Called once to initialize data structures...
1098  */
1099 int
1100 nfs_init(vfsp)
1101         struct vfsconf *vfsp;
1102 {
1103         register int i;
1104
1105         nfsmount_zone = zinit("NFSMOUNT", sizeof(struct nfsmount), 0, 0, 1);
1106
1107         nfs_mount_type = vfsp->vfc_typenum;
1108         nfsrtt.pos = 0;
1109         rpc_vers = txdr_unsigned(RPC_VER2);
1110         rpc_call = txdr_unsigned(RPC_CALL);
1111         rpc_reply = txdr_unsigned(RPC_REPLY);
1112         rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
1113         rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
1114         rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
1115         rpc_autherr = txdr_unsigned(RPC_AUTHERR);
1116         rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
1117         rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4);
1118         nfs_prog = txdr_unsigned(NFS_PROG);
1119         nqnfs_prog = txdr_unsigned(NQNFS_PROG);
1120         nfs_true = txdr_unsigned(TRUE);
1121         nfs_false = txdr_unsigned(FALSE);
1122         nfs_xdrneg1 = txdr_unsigned(-1);
1123         nfs_ticks = (hz * NFS_TICKINTVL + 500) / 1000;
1124         if (nfs_ticks < 1)
1125                 nfs_ticks = 1;
1126         /* Ensure async daemons disabled */
1127         for (i = 0; i < NFS_MAXASYNCDAEMON; i++) {
1128                 nfs_iodwant[i] = (struct proc *)0;
1129                 nfs_iodmount[i] = (struct nfsmount *)0;
1130         }
1131         nfs_nhinit();                   /* Init the nfsnode table */
1132 #ifndef NFS_NOSERVER
1133         nfsrv_init(0);                  /* Init server data structures */
1134         nfsrv_initcache();              /* Init the server request cache */
1135 #endif
1136
1137         /*
1138          * Initialize the nqnfs server stuff.
1139          */
1140         if (nqnfsstarttime == 0) {
1141                 nqnfsstarttime = boottime.tv_sec + nqsrv_maxlease
1142                         + nqsrv_clockskew + nqsrv_writeslack;
1143                 NQLOADNOVRAM(nqnfsstarttime);
1144                 TAILQ_INIT(&nqtimerhead);
1145                 nqfhhashtbl = hashinit(NQLCHSZ, M_NQLEASE, &nqfhhash);
1146         }
1147
1148         /*
1149          * Initialize reply list and start timer
1150          */
1151         TAILQ_INIT(&nfs_reqq);
1152
1153         nfs_timer(0);
1154
1155         /*
1156          * Set up lease_check and lease_updatetime so that other parts
1157          * of the system can call us, if we are loadable.
1158          */
1159 #ifndef NFS_NOSERVER
1160         nfs_prev_vop_lease_check = default_vnodeop_p[VOFFSET(vop_lease)];
1161         default_vnodeop_p[VOFFSET(vop_lease)] = (vop_t *)nqnfs_vop_lease_check;
1162 #endif
1163         nfs_prev_lease_updatetime = lease_updatetime;
1164         lease_updatetime = nfs_lease_updatetime;
1165         nfs_prev_nfssvc_sy_narg = sysent[SYS_nfssvc].sy_narg;
1166         sysent[SYS_nfssvc].sy_narg = 2;
1167         nfs_prev_nfssvc_sy_call = sysent[SYS_nfssvc].sy_call;
1168         sysent[SYS_nfssvc].sy_call = (sy_call_t *)nfssvc;
1169
1170         nfs_pbuf_freecnt = nswbuf / 2 + 1;
1171
1172         return (0);
1173 }
1174
1175 int
1176 nfs_uninit(vfsp)
1177         struct vfsconf *vfsp;
1178 {
1179
1180         untimeout(nfs_timer, (void *)NULL, nfs_timer_handle);
1181         nfs_mount_type = -1;
1182 #ifndef NFS_NOSERVER
1183         default_vnodeop_p[VOFFSET(vop_lease)] = nfs_prev_vop_lease_check;
1184 #endif
1185         lease_updatetime = nfs_prev_lease_updatetime;
1186         sysent[SYS_nfssvc].sy_narg = nfs_prev_nfssvc_sy_narg;
1187         sysent[SYS_nfssvc].sy_call = nfs_prev_nfssvc_sy_call;
1188         return (0);
1189 }
1190
1191 /*
1192  * Attribute cache routines.
1193  * nfs_loadattrcache() - loads or updates the cache contents from attributes
1194  *      that are on the mbuf list
1195  * nfs_getattrcache() - returns valid attributes if found in cache, returns
1196  *      error otherwise
1197  */
1198
1199 /*
1200  * Load the attribute cache (that lives in the nfsnode entry) with
1201  * the values on the mbuf list and
1202  * Iff vap not NULL
1203  *    copy the attributes to *vaper
1204  */
1205 int
1206 nfs_loadattrcache(vpp, mdp, dposp, vaper, dontshrink)
1207         struct vnode **vpp;
1208         struct mbuf **mdp;
1209         caddr_t *dposp;
1210         struct vattr *vaper;
1211         int dontshrink;
1212 {
1213         register struct vnode *vp = *vpp;
1214         register struct vattr *vap;
1215         register struct nfs_fattr *fp;
1216         register struct nfsnode *np;
1217         register int32_t t1;
1218         caddr_t cp2;
1219         int error = 0, rdev;
1220         struct mbuf *md;
1221         enum vtype vtyp;
1222         u_short vmode;
1223         struct timespec mtime;
1224         int v3 = NFS_ISV3(vp);
1225
1226         md = *mdp;
1227         t1 = (mtod(md, caddr_t) + md->m_len) - *dposp;
1228         if ((error = nfsm_disct(mdp, dposp, NFSX_FATTR(v3), t1, &cp2)) != 0)
1229                 return (error);
1230         fp = (struct nfs_fattr *)cp2;
1231         if (v3) {
1232                 vtyp = nfsv3tov_type(fp->fa_type);
1233                 vmode = fxdr_unsigned(u_short, fp->fa_mode);
1234                 rdev = makeudev(fxdr_unsigned(int, fp->fa3_rdev.specdata1),
1235                         fxdr_unsigned(int, fp->fa3_rdev.specdata2));
1236                 fxdr_nfsv3time(&fp->fa3_mtime, &mtime);
1237         } else {
1238                 vtyp = nfsv2tov_type(fp->fa_type);
1239                 vmode = fxdr_unsigned(u_short, fp->fa_mode);
1240                 /*
1241                  * XXX
1242                  *
1243                  * The duplicate information returned in fa_type and fa_mode
1244                  * is an ambiguity in the NFS version 2 protocol.
1245                  *
1246                  * VREG should be taken literally as a regular file.  If a
1247                  * server intents to return some type information differently
1248                  * in the upper bits of the mode field (e.g. for sockets, or
1249                  * FIFOs), NFSv2 mandates fa_type to be VNON.  Anyway, we
1250                  * leave the examination of the mode bits even in the VREG
1251                  * case to avoid breakage for bogus servers, but we make sure
1252                  * that there are actually type bits set in the upper part of
1253                  * fa_mode (and failing that, trust the va_type field).
1254                  *
1255                  * NFSv3 cleared the issue, and requires fa_mode to not
1256                  * contain any type information (while also introduing sockets
1257                  * and FIFOs for fa_type).
1258                  */
1259                 if (vtyp == VNON || (vtyp == VREG && (vmode & S_IFMT) != 0))
1260                         vtyp = IFTOVT(vmode);
1261                 rdev = fxdr_unsigned(int32_t, fp->fa2_rdev);
1262                 fxdr_nfsv2time(&fp->fa2_mtime, &mtime);
1263
1264                 /*
1265                  * Really ugly NFSv2 kludge.
1266                  */
1267                 if (vtyp == VCHR && rdev == 0xffffffff)
1268                         vtyp = VFIFO;
1269         }
1270
1271         /*
1272          * If v_type == VNON it is a new node, so fill in the v_type,
1273          * n_mtime fields. Check to see if it represents a special
1274          * device, and if so, check for a possible alias. Once the
1275          * correct vnode has been obtained, fill in the rest of the
1276          * information.
1277          */
1278         np = VTONFS(vp);
1279         if (vp->v_type != vtyp) {
1280                 vp->v_type = vtyp;
1281                 if (vp->v_type == VFIFO) {
1282                         vp->v_op = fifo_nfsv2nodeop_p;
1283                 }
1284                 if (vp->v_type == VCHR || vp->v_type == VBLK) {
1285                         vp->v_op = spec_nfsv2nodeop_p;
1286                         vp = addaliasu(vp, rdev);
1287                         np->n_vnode = vp;
1288                 }
1289                 np->n_mtime = mtime.tv_sec;
1290         }
1291         vap = &np->n_vattr;
1292         vap->va_type = vtyp;
1293         vap->va_mode = (vmode & 07777);
1294         vap->va_rdev = rdev;
1295         vap->va_mtime = mtime;
1296         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
1297         if (v3) {
1298                 vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
1299                 vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1300                 vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1301                 vap->va_size = fxdr_hyper(&fp->fa3_size);
1302                 vap->va_blocksize = NFS_FABLKSIZE;
1303                 vap->va_bytes = fxdr_hyper(&fp->fa3_used);
1304                 vap->va_fileid = fxdr_unsigned(int32_t,
1305                     fp->fa3_fileid.nfsuquad[1]);
1306                 fxdr_nfsv3time(&fp->fa3_atime, &vap->va_atime);
1307                 fxdr_nfsv3time(&fp->fa3_ctime, &vap->va_ctime);
1308                 vap->va_flags = 0;
1309                 vap->va_filerev = 0;
1310         } else {
1311                 vap->va_nlink = fxdr_unsigned(u_short, fp->fa_nlink);
1312                 vap->va_uid = fxdr_unsigned(uid_t, fp->fa_uid);
1313                 vap->va_gid = fxdr_unsigned(gid_t, fp->fa_gid);
1314                 vap->va_size = fxdr_unsigned(u_int32_t, fp->fa2_size);
1315                 vap->va_blocksize = fxdr_unsigned(int32_t, fp->fa2_blocksize);
1316                 vap->va_bytes = (u_quad_t)fxdr_unsigned(int32_t, fp->fa2_blocks)
1317                     * NFS_FABLKSIZE;
1318                 vap->va_fileid = fxdr_unsigned(int32_t, fp->fa2_fileid);
1319                 fxdr_nfsv2time(&fp->fa2_atime, &vap->va_atime);
1320                 vap->va_flags = 0;
1321                 vap->va_ctime.tv_sec = fxdr_unsigned(u_int32_t,
1322                     fp->fa2_ctime.nfsv2_sec);
1323                 vap->va_ctime.tv_nsec = 0;
1324                 vap->va_gen = fxdr_unsigned(u_int32_t,fp->fa2_ctime.nfsv2_usec);
1325                 vap->va_filerev = 0;
1326         }
1327         np->n_attrstamp = time_second;
1328         if (vap->va_size != np->n_size) {
1329                 if (vap->va_type == VREG) {
1330                         if (dontshrink && vap->va_size < np->n_size) {
1331                                 /*
1332                                  * We've been told not to shrink the file;
1333                                  * zero np->n_attrstamp to indicate that
1334                                  * the attributes are stale.
1335                                  */
1336                                 vap->va_size = np->n_size;
1337                                 np->n_attrstamp = 0;
1338                         } else if (np->n_flag & NMODIFIED) {
1339                                 if (vap->va_size < np->n_size)
1340                                         vap->va_size = np->n_size;
1341                                 else
1342                                         np->n_size = vap->va_size;
1343                         } else {
1344                                 np->n_size = vap->va_size;
1345                         }
1346                         vnode_pager_setsize(vp, np->n_size);
1347                 } else {
1348                         np->n_size = vap->va_size;
1349                 }
1350         }
1351         if (vaper != NULL) {
1352                 bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
1353                 if (np->n_flag & NCHG) {
1354                         if (np->n_flag & NACC)
1355                                 vaper->va_atime = np->n_atim;
1356                         if (np->n_flag & NUPD)
1357                                 vaper->va_mtime = np->n_mtim;
1358                 }
1359         }
1360         return (0);
1361 }
1362
1363 #ifdef NFS_ACDEBUG
1364 #include <sys/sysctl.h>
1365 SYSCTL_DECL(_vfs_nfs);
1366 static int nfs_acdebug;
1367 SYSCTL_INT(_vfs_nfs, OID_AUTO, acdebug, CTLFLAG_RW, &nfs_acdebug, 0, "");
1368 #endif
1369
1370 /*
1371  * Check the time stamp
1372  * If the cache is valid, copy contents to *vap and return 0
1373  * otherwise return an error
1374  */
1375 int
1376 nfs_getattrcache(vp, vaper)
1377         register struct vnode *vp;
1378         struct vattr *vaper;
1379 {
1380         register struct nfsnode *np;
1381         register struct vattr *vap;
1382         struct nfsmount *nmp;
1383         int timeo;
1384
1385         np = VTONFS(vp);
1386         vap = &np->n_vattr;
1387         nmp = VFSTONFS(vp->v_mount);
1388         /* XXX n_mtime doesn't seem to be updated on a miss-and-reload */
1389         timeo = (time_second - np->n_mtime) / 10;
1390
1391 #ifdef NFS_ACDEBUG
1392         if (nfs_acdebug>1)
1393                 printf("nfs_getattrcache: initial timeo = %d\n", timeo);
1394 #endif
1395
1396         if (vap->va_type == VDIR) {
1397                 if ((np->n_flag & NMODIFIED) || timeo < nmp->nm_acdirmin)
1398                         timeo = nmp->nm_acdirmin;
1399                 else if (timeo > nmp->nm_acdirmax)
1400                         timeo = nmp->nm_acdirmax;
1401         } else {
1402                 if ((np->n_flag & NMODIFIED) || timeo < nmp->nm_acregmin)
1403                         timeo = nmp->nm_acregmin;
1404                 else if (timeo > nmp->nm_acregmax)
1405                         timeo = nmp->nm_acregmax;
1406         }
1407
1408 #ifdef NFS_ACDEBUG
1409         if (nfs_acdebug > 2)
1410                 printf("acregmin %d; acregmax %d; acdirmin %d; acdirmax %d\n",
1411                         nmp->nm_acregmin, nmp->nm_acregmax,
1412                         nmp->nm_acdirmin, nmp->nm_acdirmax);
1413
1414         if (nfs_acdebug)
1415                 printf("nfs_getattrcache: age = %d; final timeo = %d\n",
1416                         (time_second - np->n_attrstamp), timeo);
1417 #endif
1418
1419         if ((time_second - np->n_attrstamp) >= timeo) {
1420                 nfsstats.attrcache_misses++;
1421                 return (ENOENT);
1422         }
1423         nfsstats.attrcache_hits++;
1424         if (vap->va_size != np->n_size) {
1425                 if (vap->va_type == VREG) {
1426                         if (np->n_flag & NMODIFIED) {
1427                                 if (vap->va_size < np->n_size)
1428                                         vap->va_size = np->n_size;
1429                                 else
1430                                         np->n_size = vap->va_size;
1431                         } else {
1432                                 np->n_size = vap->va_size;
1433                         }
1434                         vnode_pager_setsize(vp, np->n_size);
1435                 } else {
1436                         np->n_size = vap->va_size;
1437                 }
1438         }
1439         bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(struct vattr));
1440         if (np->n_flag & NCHG) {
1441                 if (np->n_flag & NACC)
1442                         vaper->va_atime = np->n_atim;
1443                 if (np->n_flag & NUPD)
1444                         vaper->va_mtime = np->n_mtim;
1445         }
1446         return (0);
1447 }
1448
1449 #ifndef NFS_NOSERVER
1450 /*
1451  * Set up nameidata for a lookup() call and do it.
1452  *
1453  * If pubflag is set, this call is done for a lookup operation on the
1454  * public filehandle. In that case we allow crossing mountpoints and
1455  * absolute pathnames. However, the caller is expected to check that
1456  * the lookup result is within the public fs, and deny access if
1457  * it is not.
1458  *
1459  * nfs_namei() clears out garbage fields that namei() might leave garbage.
1460  * This is mainly ni_vp and ni_dvp when an error occurs, and ni_dvp when no
1461  * error occurs but the parent was not requested.
1462  *
1463  * dirp may be set whether an error is returned or not, and must be
1464  * released by the caller.
1465  */
1466 int
1467 nfs_namei(ndp, fhp, len, slp, nam, mdp, dposp, retdirp, p, kerbflag, pubflag)
1468         register struct nameidata *ndp;
1469         fhandle_t *fhp;
1470         int len;
1471         struct nfssvc_sock *slp;
1472         struct sockaddr *nam;
1473         struct mbuf **mdp;
1474         caddr_t *dposp;
1475         struct vnode **retdirp;
1476         struct proc *p;
1477         int kerbflag, pubflag;
1478 {
1479         register int i, rem;
1480         register struct mbuf *md;
1481         register char *fromcp, *tocp, *cp;
1482         struct iovec aiov;
1483         struct uio auio;
1484         struct vnode *dp;
1485         int error, rdonly, linklen;
1486         struct componentname *cnp = &ndp->ni_cnd;
1487
1488         *retdirp = (struct vnode *)0;
1489         cnp->cn_pnbuf = zalloc(namei_zone);
1490
1491         /*
1492          * Copy the name from the mbuf list to ndp->ni_pnbuf
1493          * and set the various ndp fields appropriately.
1494          */
1495         fromcp = *dposp;
1496         tocp = cnp->cn_pnbuf;
1497         md = *mdp;
1498         rem = mtod(md, caddr_t) + md->m_len - fromcp;
1499         for (i = 0; i < len; i++) {
1500                 while (rem == 0) {
1501                         md = md->m_next;
1502                         if (md == NULL) {
1503                                 error = EBADRPC;
1504                                 goto out;
1505                         }
1506                         fromcp = mtod(md, caddr_t);
1507                         rem = md->m_len;
1508                 }
1509                 if (*fromcp == '\0' || (!pubflag && *fromcp == '/')) {
1510                         error = EACCES;
1511                         goto out;
1512                 }
1513                 *tocp++ = *fromcp++;
1514                 rem--;
1515         }
1516         *tocp = '\0';
1517         *mdp = md;
1518         *dposp = fromcp;
1519         len = nfsm_rndup(len)-len;
1520         if (len > 0) {
1521                 if (rem >= len)
1522                         *dposp += len;
1523                 else if ((error = nfs_adv(mdp, dposp, len, rem)) != 0)
1524                         goto out;
1525         }
1526
1527         /*
1528          * Extract and set starting directory.
1529          */
1530         error = nfsrv_fhtovp(fhp, FALSE, &dp, ndp->ni_cnd.cn_cred, slp,
1531             nam, &rdonly, kerbflag, pubflag);
1532         if (error)
1533                 goto out;
1534         if (dp->v_type != VDIR) {
1535                 vrele(dp);
1536                 error = ENOTDIR;
1537                 goto out;
1538         }
1539
1540         if (rdonly)
1541                 cnp->cn_flags |= RDONLY;
1542
1543         /*
1544          * Set return directory.  Reference to dp is implicitly transfered
1545          * to the returned pointer
1546          */
1547         *retdirp = dp;
1548
1549         if (pubflag) {
1550                 /*
1551                  * Oh joy. For WebNFS, handle those pesky '%' escapes,
1552                  * and the 'native path' indicator.
1553                  */
1554                 cp = zalloc(namei_zone);
1555                 fromcp = cnp->cn_pnbuf;
1556                 tocp = cp;
1557                 if ((unsigned char)*fromcp >= WEBNFS_SPECCHAR_START) {
1558                         switch ((unsigned char)*fromcp) {
1559                         case WEBNFS_NATIVE_CHAR:
1560                                 /*
1561                                  * 'Native' path for us is the same
1562                                  * as a path according to the NFS spec,
1563                                  * just skip the escape char.
1564                                  */
1565                                 fromcp++;
1566                                 break;
1567                         /*
1568                          * More may be added in the future, range 0x80-0xff
1569                          */
1570                         default:
1571                                 error = EIO;
1572                                 zfree(namei_zone, cp);
1573                                 goto out;
1574                         }
1575                 }
1576                 /*
1577                  * Translate the '%' escapes, URL-style.
1578                  */
1579                 while (*fromcp != '\0') {
1580                         if (*fromcp == WEBNFS_ESC_CHAR) {
1581                                 if (fromcp[1] != '\0' && fromcp[2] != '\0') {
1582                                         fromcp++;
1583                                         *tocp++ = HEXSTRTOI(fromcp);
1584                                         fromcp += 2;
1585                                         continue;
1586                                 } else {
1587                                         error = ENOENT;
1588                                         zfree(namei_zone, cp);
1589                                         goto out;
1590                                 }
1591                         } else
1592                                 *tocp++ = *fromcp++;
1593                 }
1594                 *tocp = '\0';
1595                 zfree(namei_zone, cnp->cn_pnbuf);
1596                 cnp->cn_pnbuf = cp;
1597         }
1598
1599         ndp->ni_pathlen = (tocp - cnp->cn_pnbuf) + 1;
1600         ndp->ni_segflg = UIO_SYSSPACE;
1601
1602         if (pubflag) {
1603                 ndp->ni_rootdir = rootvnode;
1604                 ndp->ni_loopcnt = 0;
1605                 if (cnp->cn_pnbuf[0] == '/')
1606                         dp = rootvnode;
1607         } else {
1608                 cnp->cn_flags |= NOCROSSMOUNT;
1609         }
1610
1611         /*
1612          * Initialize for scan, set ni_startdir and bump ref on dp again
1613          * becuase lookup() will dereference ni_startdir.
1614          */
1615
1616         cnp->cn_proc = p;
1617         VREF(dp);
1618         ndp->ni_startdir = dp;
1619
1620         for (;;) {
1621                 cnp->cn_nameptr = cnp->cn_pnbuf;
1622                 /*
1623                  * Call lookup() to do the real work.  If an error occurs,
1624                  * ndp->ni_vp and ni_dvp are left uninitialized or NULL and
1625                  * we do not have to dereference anything before returning.
1626                  * In either case ni_startdir will be dereferenced and NULLed
1627                  * out.
1628                  */
1629                 error = lookup(ndp);
1630                 if (error)
1631                         break;
1632
1633                 /*
1634                  * Check for encountering a symbolic link.  Trivial
1635                  * termination occurs if no symlink encountered.
1636                  * Note: zfree is safe because error is 0, so we will
1637                  * not zfree it again when we break.
1638                  */
1639                 if ((cnp->cn_flags & ISSYMLINK) == 0) {
1640                         nfsrv_object_create(ndp->ni_vp);
1641                         if (cnp->cn_flags & (SAVENAME | SAVESTART))
1642                                 cnp->cn_flags |= HASBUF;
1643                         else
1644                                 zfree(namei_zone, cnp->cn_pnbuf);
1645                         break;
1646                 }
1647
1648                 /*
1649                  * Validate symlink
1650                  */
1651                 if ((cnp->cn_flags & LOCKPARENT) && ndp->ni_pathlen == 1)
1652                         VOP_UNLOCK(ndp->ni_dvp, 0, p);
1653                 if (!pubflag) {
1654                         error = EINVAL;
1655                         goto badlink2;
1656                 }
1657
1658                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
1659                         error = ELOOP;
1660                         goto badlink2;
1661                 }
1662                 if (ndp->ni_pathlen > 1)
1663                         cp = zalloc(namei_zone);
1664                 else
1665                         cp = cnp->cn_pnbuf;
1666                 aiov.iov_base = cp;
1667                 aiov.iov_len = MAXPATHLEN;
1668                 auio.uio_iov = &aiov;
1669                 auio.uio_iovcnt = 1;
1670                 auio.uio_offset = 0;
1671                 auio.uio_rw = UIO_READ;
1672                 auio.uio_segflg = UIO_SYSSPACE;
1673                 auio.uio_procp = (struct proc *)0;
1674                 auio.uio_resid = MAXPATHLEN;
1675                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
1676                 if (error) {
1677                 badlink1:
1678                         if (ndp->ni_pathlen > 1)
1679                                 zfree(namei_zone, cp);
1680                 badlink2:
1681                         vrele(ndp->ni_dvp);
1682                         vput(ndp->ni_vp);
1683                         break;
1684                 }
1685                 linklen = MAXPATHLEN - auio.uio_resid;
1686                 if (linklen == 0) {
1687                         error = ENOENT;
1688                         goto badlink1;
1689                 }
1690                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
1691                         error = ENAMETOOLONG;
1692                         goto badlink1;
1693                 }
1694
1695                 /*
1696                  * Adjust or replace path
1697                  */
1698                 if (ndp->ni_pathlen > 1) {
1699                         bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
1700                         zfree(namei_zone, cnp->cn_pnbuf);
1701                         cnp->cn_pnbuf = cp;
1702                 } else
1703                         cnp->cn_pnbuf[linklen] = '\0';
1704                 ndp->ni_pathlen += linklen;
1705
1706                 /*
1707                  * Cleanup refs for next loop and check if root directory
1708                  * should replace current directory.  Normally ni_dvp
1709                  * becomes the new base directory and is cleaned up when
1710                  * we loop.  Explicitly null pointers after invalidation
1711                  * to clarify operation.
1712                  */
1713                 vput(ndp->ni_vp);
1714                 ndp->ni_vp = NULL;
1715
1716                 if (cnp->cn_pnbuf[0] == '/') {
1717                         vrele(ndp->ni_dvp);
1718                         ndp->ni_dvp = ndp->ni_rootdir;
1719                         VREF(ndp->ni_dvp);
1720                 }
1721                 ndp->ni_startdir = ndp->ni_dvp;
1722                 ndp->ni_dvp = NULL;
1723         }
1724
1725         /*
1726          * nfs_namei() guarentees that fields will not contain garbage
1727          * whether an error occurs or not.  This allows the caller to track
1728          * cleanup state trivially.
1729          */
1730 out:
1731         if (error) {
1732                 zfree(namei_zone, cnp->cn_pnbuf);
1733                 ndp->ni_vp = NULL;
1734                 ndp->ni_dvp = NULL;
1735                 ndp->ni_startdir = NULL;
1736                 cnp->cn_flags &= ~HASBUF;
1737         } else if ((ndp->ni_cnd.cn_flags & (WANTPARENT|LOCKPARENT)) == 0) {
1738                 ndp->ni_dvp = NULL;
1739         }
1740         return (error);
1741 }
1742
1743 /*
1744  * A fiddled version of m_adj() that ensures null fill to a long
1745  * boundary and only trims off the back end
1746  */
1747 void
1748 nfsm_adj(mp, len, nul)
1749         struct mbuf *mp;
1750         register int len;
1751         int nul;
1752 {
1753         register struct mbuf *m;
1754         register int count, i;
1755         register char *cp;
1756
1757         /*
1758          * Trim from tail.  Scan the mbuf chain,
1759          * calculating its length and finding the last mbuf.
1760          * If the adjustment only affects this mbuf, then just
1761          * adjust and return.  Otherwise, rescan and truncate
1762          * after the remaining size.
1763          */
1764         count = 0;
1765         m = mp;
1766         for (;;) {
1767                 count += m->m_len;
1768                 if (m->m_next == (struct mbuf *)0)
1769                         break;
1770                 m = m->m_next;
1771         }
1772         if (m->m_len > len) {
1773                 m->m_len -= len;
1774                 if (nul > 0) {
1775                         cp = mtod(m, caddr_t)+m->m_len-nul;
1776                         for (i = 0; i < nul; i++)
1777                                 *cp++ = '\0';
1778                 }
1779                 return;
1780         }
1781         count -= len;
1782         if (count < 0)
1783                 count = 0;
1784         /*
1785          * Correct length for chain is "count".
1786          * Find the mbuf with last data, adjust its length,
1787          * and toss data from remaining mbufs on chain.
1788          */
1789         for (m = mp; m; m = m->m_next) {
1790                 if (m->m_len >= count) {
1791                         m->m_len = count;
1792                         if (nul > 0) {
1793                                 cp = mtod(m, caddr_t)+m->m_len-nul;
1794                                 for (i = 0; i < nul; i++)
1795                                         *cp++ = '\0';
1796                         }
1797                         break;
1798                 }
1799                 count -= m->m_len;
1800         }
1801         for (m = m->m_next;m;m = m->m_next)
1802                 m->m_len = 0;
1803 }
1804
1805 /*
1806  * Make these functions instead of macros, so that the kernel text size
1807  * doesn't get too big...
1808  */
1809 void
1810 nfsm_srvwcc(nfsd, before_ret, before_vap, after_ret, after_vap, mbp, bposp)
1811         struct nfsrv_descript *nfsd;
1812         int before_ret;
1813         register struct vattr *before_vap;
1814         int after_ret;
1815         struct vattr *after_vap;
1816         struct mbuf **mbp;
1817         char **bposp;
1818 {
1819         register struct mbuf *mb = *mbp, *mb2;
1820         register char *bpos = *bposp;
1821         register u_int32_t *tl;
1822
1823         if (before_ret) {
1824                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1825                 *tl = nfs_false;
1826         } else {
1827                 nfsm_build(tl, u_int32_t *, 7 * NFSX_UNSIGNED);
1828                 *tl++ = nfs_true;
1829                 txdr_hyper(before_vap->va_size, tl);
1830                 tl += 2;
1831                 txdr_nfsv3time(&(before_vap->va_mtime), tl);
1832                 tl += 2;
1833                 txdr_nfsv3time(&(before_vap->va_ctime), tl);
1834         }
1835         *bposp = bpos;
1836         *mbp = mb;
1837         nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp);
1838 }
1839
1840 void
1841 nfsm_srvpostopattr(nfsd, after_ret, after_vap, mbp, bposp)
1842         struct nfsrv_descript *nfsd;
1843         int after_ret;
1844         struct vattr *after_vap;
1845         struct mbuf **mbp;
1846         char **bposp;
1847 {
1848         register struct mbuf *mb = *mbp, *mb2;
1849         register char *bpos = *bposp;
1850         register u_int32_t *tl;
1851         register struct nfs_fattr *fp;
1852
1853         if (after_ret) {
1854                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED);
1855                 *tl = nfs_false;
1856         } else {
1857                 nfsm_build(tl, u_int32_t *, NFSX_UNSIGNED + NFSX_V3FATTR);
1858                 *tl++ = nfs_true;
1859                 fp = (struct nfs_fattr *)tl;
1860                 nfsm_srvfattr(nfsd, after_vap, fp);
1861         }
1862         *mbp = mb;
1863         *bposp = bpos;
1864 }
1865
1866 void
1867 nfsm_srvfattr(nfsd, vap, fp)
1868         register struct nfsrv_descript *nfsd;
1869         register struct vattr *vap;
1870         register struct nfs_fattr *fp;
1871 {
1872
1873         fp->fa_nlink = txdr_unsigned(vap->va_nlink);
1874         fp->fa_uid = txdr_unsigned(vap->va_uid);
1875         fp->fa_gid = txdr_unsigned(vap->va_gid);
1876         if (nfsd->nd_flag & ND_NFSV3) {
1877                 fp->fa_type = vtonfsv3_type(vap->va_type);
1878                 fp->fa_mode = vtonfsv3_mode(vap->va_mode);
1879                 txdr_hyper(vap->va_size, &fp->fa3_size);
1880                 txdr_hyper(vap->va_bytes, &fp->fa3_used);
1881                 fp->fa3_rdev.specdata1 = txdr_unsigned(umajor(vap->va_rdev));
1882                 fp->fa3_rdev.specdata2 = txdr_unsigned(uminor(vap->va_rdev));
1883                 fp->fa3_fsid.nfsuquad[0] = 0;
1884                 fp->fa3_fsid.nfsuquad[1] = txdr_unsigned(vap->va_fsid);
1885                 fp->fa3_fileid.nfsuquad[0] = 0;
1886                 fp->fa3_fileid.nfsuquad[1] = txdr_unsigned(vap->va_fileid);
1887                 txdr_nfsv3time(&vap->va_atime, &fp->fa3_atime);
1888                 txdr_nfsv3time(&vap->va_mtime, &fp->fa3_mtime);
1889                 txdr_nfsv3time(&vap->va_ctime, &fp->fa3_ctime);
1890         } else {
1891                 fp->fa_type = vtonfsv2_type(vap->va_type);
1892                 fp->fa_mode = vtonfsv2_mode(vap->va_type, vap->va_mode);
1893                 fp->fa2_size = txdr_unsigned(vap->va_size);
1894                 fp->fa2_blocksize = txdr_unsigned(vap->va_blocksize);
1895                 if (vap->va_type == VFIFO)
1896                         fp->fa2_rdev = 0xffffffff;
1897                 else
1898                         fp->fa2_rdev = txdr_unsigned(vap->va_rdev);
1899                 fp->fa2_blocks = txdr_unsigned(vap->va_bytes / NFS_FABLKSIZE);
1900                 fp->fa2_fsid = txdr_unsigned(vap->va_fsid);
1901                 fp->fa2_fileid = txdr_unsigned(vap->va_fileid);
1902                 txdr_nfsv2time(&vap->va_atime, &fp->fa2_atime);
1903                 txdr_nfsv2time(&vap->va_mtime, &fp->fa2_mtime);
1904                 txdr_nfsv2time(&vap->va_ctime, &fp->fa2_ctime);
1905         }
1906 }
1907
1908 /*
1909  * nfsrv_fhtovp() - convert a fh to a vnode ptr (optionally locked)
1910  *      - look up fsid in mount list (if not found ret error)
1911  *      - get vp and export rights by calling VFS_FHTOVP()
1912  *      - if cred->cr_uid == 0 or MNT_EXPORTANON set it to credanon
1913  *      - if not lockflag unlock it with VOP_UNLOCK()
1914  */
1915 int
1916 nfsrv_fhtovp(fhp, lockflag, vpp, cred, slp, nam, rdonlyp, kerbflag, pubflag)
1917         fhandle_t *fhp;
1918         int lockflag;
1919         struct vnode **vpp;
1920         struct ucred *cred;
1921         struct nfssvc_sock *slp;
1922         struct sockaddr *nam;
1923         int *rdonlyp;
1924         int kerbflag;
1925         int pubflag;
1926 {
1927         struct proc *p = curproc; /* XXX */
1928         register struct mount *mp;
1929         register int i;
1930         struct ucred *credanon;
1931         int error, exflags;
1932 #ifdef MNT_EXNORESPORT          /* XXX needs mountd and /etc/exports help yet */
1933         struct sockaddr_int *saddr;
1934 #endif
1935
1936         *vpp = (struct vnode *)0;
1937
1938         if (nfs_ispublicfh(fhp)) {
1939                 if (!pubflag || !nfs_pub.np_valid)
1940                         return (ESTALE);
1941                 fhp = &nfs_pub.np_handle;
1942         }
1943
1944         mp = vfs_getvfs(&fhp->fh_fsid);
1945         if (!mp)
1946                 return (ESTALE);
1947         error = VFS_CHECKEXP(mp, nam, &exflags, &credanon);
1948         if (error)
1949                 return (error);
1950         error = VFS_FHTOVP(mp, &fhp->fh_fid, vpp);
1951         if (error)
1952                 return (error);
1953 #ifdef MNT_EXNORESPORT
1954         if (!(exflags & (MNT_EXNORESPORT|MNT_EXPUBLIC))) {
1955                 saddr = (struct sockaddr_in *)nam;
1956                 if (saddr->sin_family == AF_INET &&
1957                     ntohs(saddr->sin_port) >= IPPORT_RESERVED) {
1958                         vput(*vpp);
1959                         *vpp = NULL;
1960                         return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1961                 }
1962         }
1963 #endif
1964         /*
1965          * Check/setup credentials.
1966          */
1967         if (exflags & MNT_EXKERB) {
1968                 if (!kerbflag) {
1969                         vput(*vpp);
1970                         *vpp = NULL;
1971                         return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1972                 }
1973         } else if (kerbflag) {
1974                 vput(*vpp);
1975                 *vpp = NULL;
1976                 return (NFSERR_AUTHERR | AUTH_TOOWEAK);
1977         } else if (cred->cr_uid == 0 || (exflags & MNT_EXPORTANON)) {
1978                 cred->cr_uid = credanon->cr_uid;
1979                 for (i = 0; i < credanon->cr_ngroups && i < NGROUPS; i++)
1980                         cred->cr_groups[i] = credanon->cr_groups[i];
1981                 cred->cr_ngroups = i;
1982         }
1983         if (exflags & MNT_EXRDONLY)
1984                 *rdonlyp = 1;
1985         else
1986                 *rdonlyp = 0;
1987
1988         nfsrv_object_create(*vpp);
1989
1990         if (!lockflag)
1991                 VOP_UNLOCK(*vpp, 0, p);
1992         return (0);
1993 }
1994
1995
1996 /*
1997  * WebNFS: check if a filehandle is a public filehandle. For v3, this
1998  * means a length of 0, for v2 it means all zeroes. nfsm_srvmtofh has
1999  * transformed this to all zeroes in both cases, so check for it.
2000  */
2001 int
2002 nfs_ispublicfh(fhp)
2003         fhandle_t *fhp;
2004 {
2005         char *cp = (char *)fhp;
2006         int i;
2007
2008         for (i = 0; i < NFSX_V3FH; i++)
2009                 if (*cp++ != 0)
2010                         return (FALSE);
2011         return (TRUE);
2012 }
2013
2014 #endif /* NFS_NOSERVER */
2015 /*
2016  * This function compares two net addresses by family and returns TRUE
2017  * if they are the same host.
2018  * If there is any doubt, return FALSE.
2019  * The AF_INET family is handled as a special case so that address mbufs
2020  * don't need to be saved to store "struct in_addr", which is only 4 bytes.
2021  */
2022 int
2023 netaddr_match(family, haddr, nam)
2024         int family;
2025         union nethostaddr *haddr;
2026         struct sockaddr *nam;
2027 {
2028         register struct sockaddr_in *inetaddr;
2029
2030         switch (family) {
2031         case AF_INET:
2032                 inetaddr = (struct sockaddr_in *)nam;
2033                 if (inetaddr->sin_family == AF_INET &&
2034                     inetaddr->sin_addr.s_addr == haddr->had_inetaddr)
2035                         return (1);
2036                 break;
2037         default:
2038                 break;
2039         };
2040         return (0);
2041 }
2042
2043 static nfsuint64 nfs_nullcookie = { { 0, 0 } };
2044 /*
2045  * This function finds the directory cookie that corresponds to the
2046  * logical byte offset given.
2047  */
2048 nfsuint64 *
2049 nfs_getcookie(np, off, add)
2050         register struct nfsnode *np;
2051         off_t off;
2052         int add;
2053 {
2054         register struct nfsdmap *dp, *dp2;
2055         register int pos;
2056
2057         pos = (uoff_t)off / NFS_DIRBLKSIZ;
2058         if (pos == 0 || off < 0) {
2059 #ifdef DIAGNOSTIC
2060                 if (add)
2061                         panic("nfs getcookie add at <= 0");
2062 #endif
2063                 return (&nfs_nullcookie);
2064         }
2065         pos--;
2066         dp = np->n_cookies.lh_first;
2067         if (!dp) {
2068                 if (add) {
2069                         MALLOC(dp, struct nfsdmap *, sizeof (struct nfsdmap),
2070                                 M_NFSDIROFF, M_WAITOK);
2071                         dp->ndm_eocookie = 0;
2072                         LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
2073                 } else
2074                         return ((nfsuint64 *)0);
2075         }
2076         while (pos >= NFSNUMCOOKIES) {
2077                 pos -= NFSNUMCOOKIES;
2078                 if (dp->ndm_list.le_next) {
2079                         if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
2080                                 pos >= dp->ndm_eocookie)
2081                                 return ((nfsuint64 *)0);
2082                         dp = dp->ndm_list.le_next;
2083                 } else if (add) {
2084                         MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap),
2085                                 M_NFSDIROFF, M_WAITOK);
2086                         dp2->ndm_eocookie = 0;
2087                         LIST_INSERT_AFTER(dp, dp2, ndm_list);
2088                         dp = dp2;
2089                 } else
2090                         return ((nfsuint64 *)0);
2091         }
2092         if (pos >= dp->ndm_eocookie) {
2093                 if (add)
2094                         dp->ndm_eocookie = pos + 1;
2095                 else
2096                         return ((nfsuint64 *)0);
2097         }
2098         return (&dp->ndm_cookies[pos]);
2099 }
2100
2101 /*
2102  * Invalidate cached directory information, except for the actual directory
2103  * blocks (which are invalidated separately).
2104  * Done mainly to avoid the use of stale offset cookies.
2105  */
2106 void
2107 nfs_invaldir(vp)
2108         register struct vnode *vp;
2109 {
2110         register struct nfsnode *np = VTONFS(vp);
2111
2112 #ifdef DIAGNOSTIC
2113         if (vp->v_type != VDIR)
2114                 panic("nfs: invaldir not dir");
2115 #endif
2116         np->n_direofoffset = 0;
2117         np->n_cookieverf.nfsuquad[0] = 0;
2118         np->n_cookieverf.nfsuquad[1] = 0;
2119         if (np->n_cookies.lh_first)
2120                 np->n_cookies.lh_first->ndm_eocookie = 0;
2121 }
2122
2123 /*
2124  * The write verifier has changed (probably due to a server reboot), so all
2125  * B_NEEDCOMMIT blocks will have to be written again. Since they are on the
2126  * dirty block list as B_DELWRI, all this takes is clearing the B_NEEDCOMMIT
2127  * and B_CLUSTEROK flags.  Once done the new write verifier can be set for the
2128  * mount point.
2129  *
2130  * B_CLUSTEROK must be cleared along with B_NEEDCOMMIT because stage 1 data
2131  * writes are not clusterable.
2132  */
2133 void
2134 nfs_clearcommit(mp)
2135         struct mount *mp;
2136 {
2137         register struct vnode *vp, *nvp;
2138         register struct buf *bp, *nbp;
2139         int s;
2140
2141         s = splbio();
2142         mtx_assert(&Giant, MA_OWNED);
2143         mtx_assert(&vm_mtx, MA_NOTOWNED);
2144 loop:
2145         for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
2146                 if (vp->v_mount != mp)  /* Paranoia */
2147                         goto loop;
2148                 nvp = vp->v_mntvnodes.le_next;
2149                 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
2150                         nbp = TAILQ_NEXT(bp, b_vnbufs);
2151                         if (BUF_REFCNT(bp) == 0 &&
2152                             (bp->b_flags & (B_DELWRI | B_NEEDCOMMIT))
2153                                 == (B_DELWRI | B_NEEDCOMMIT))
2154                                 bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK);
2155                 }
2156         }
2157         splx(s);
2158 }
2159
2160 #ifndef NFS_NOSERVER
2161 /*
2162  * Map errnos to NFS error numbers. For Version 3 also filter out error
2163  * numbers not specified for the associated procedure.
2164  */
2165 int
2166 nfsrv_errmap(nd, err)
2167         struct nfsrv_descript *nd;
2168         register int err;
2169 {
2170         register short *defaulterrp, *errp;
2171
2172         if (nd->nd_flag & ND_NFSV3) {
2173             if (nd->nd_procnum <= NFSPROC_COMMIT) {
2174                 errp = defaulterrp = nfsrv_v3errmap[nd->nd_procnum];
2175                 while (*++errp) {
2176                         if (*errp == err)
2177                                 return (err);
2178                         else if (*errp > err)
2179                                 break;
2180                 }
2181                 return ((int)*defaulterrp);
2182             } else
2183                 return (err & 0xffff);
2184         }
2185         if (err <= ELAST)
2186                 return ((int)nfsrv_v2errmap[err - 1]);
2187         return (NFSERR_IO);
2188 }
2189
2190 int
2191 nfsrv_object_create(vp)
2192         struct vnode *vp;
2193 {
2194
2195         if (vp == NULL || vp->v_type != VREG)
2196                 return (1);
2197         return (vfs_object_create(vp, curproc,
2198                                   curproc ? curproc->p_ucred : NULL));
2199 }
2200
2201 /*
2202  * Sort the group list in increasing numerical order.
2203  * (Insertion sort by Chris Torek, who was grossed out by the bubble sort
2204  *  that used to be here.)
2205  */
2206 void
2207 nfsrvw_sort(list, num)
2208         register gid_t *list;
2209         register int num;
2210 {
2211         register int i, j;
2212         gid_t v;
2213
2214         /* Insertion sort. */
2215         for (i = 1; i < num; i++) {
2216                 v = list[i];
2217                 /* find correct slot for value v, moving others up */
2218                 for (j = i; --j >= 0 && v < list[j];)
2219                         list[j + 1] = list[j];
2220                 list[j + 1] = v;
2221         }
2222 }
2223
2224 /*
2225  * copy credentials making sure that the result can be compared with bcmp().
2226  */
2227 void
2228 nfsrv_setcred(incred, outcred)
2229         register struct ucred *incred, *outcred;
2230 {
2231         register int i;
2232
2233         bzero((caddr_t)outcred, sizeof (struct ucred));
2234         outcred->cr_ref = 1;
2235         outcred->cr_uid = incred->cr_uid;
2236         outcred->cr_ngroups = incred->cr_ngroups;
2237         for (i = 0; i < incred->cr_ngroups; i++)
2238                 outcred->cr_groups[i] = incred->cr_groups[i];
2239         nfsrvw_sort(outcred->cr_groups, outcred->cr_ngroups);
2240 }
2241 #endif /* NFS_NOSERVER */