sys/vfs/smbfs/smbfs_vnops.c

   1 /*
   2  * Copyright (c) 2000-2001 Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/fs/smbfs/smbfs_vnops.c,v 1.2.2.8 2003/04/04 08:57:23 tjr Exp $
  33  * $DragonFly: src/sys/vfs/smbfs/smbfs_vnops.c,v 1.41 2007/11/20 21:03:50 dillon Exp $
  34  */
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/proc.h>
  39 #include <sys/namei.h>
  40 #include <sys/fcntl.h>
  41 #include <sys/mount.h>
  42 #include <sys/unistd.h>
  43 #include <sys/vnode.h>
  44 #include <sys/lockf.h>
  45
  46 #include <vm/vm.h>
  47 #include <vm/vm_extern.h>
  48 #include <vm/vm_zone.h>
  49
  50
  51 #include <netproto/smb/smb.h>
  52 #include <netproto/smb/smb_conn.h>
  53 #include <netproto/smb/smb_subr.h>
  54
  55 #include "smbfs.h"
  56 #include "smbfs_node.h"
  57 #include "smbfs_subr.h"
  58
  59 #include <sys/buf.h>
  60
  61 /*
  62  * Prototypes for SMBFS vnode operations
  63  */
  64 static int smbfs_create(struct vop_old_create_args *);
  65 static int smbfs_mknod(struct vop_old_mknod_args *);
  66 static int smbfs_open(struct vop_open_args *);
  67 static int smbfs_closel(struct vop_close_args *);
  68 static int smbfs_access(struct vop_access_args *);
  69 static int smbfs_getattr(struct vop_getattr_args *);
  70 static int smbfs_setattr(struct vop_setattr_args *);
  71 static int smbfs_read(struct vop_read_args *);
  72 static int smbfs_write(struct vop_write_args *);
  73 static int smbfs_fsync(struct vop_fsync_args *);
  74 static int smbfs_remove(struct vop_old_remove_args *);
  75 static int smbfs_link(struct vop_old_link_args *);
  76 static int smbfs_lookup(struct vop_old_lookup_args *);
  77 static int smbfs_rename(struct vop_old_rename_args *);
  78 static int smbfs_mkdir(struct vop_old_mkdir_args *);
  79 static int smbfs_rmdir(struct vop_old_rmdir_args *);
  80 static int smbfs_symlink(struct vop_old_symlink_args *);
  81 static int smbfs_readdir(struct vop_readdir_args *);
  82 static int smbfs_bmap(struct vop_bmap_args *);
  83 static int smbfs_strategy(struct vop_strategy_args *);
  84 static int smbfs_print(struct vop_print_args *);
  85 static int smbfs_pathconf(struct vop_pathconf_args *ap);
  86 static int smbfs_advlock(struct vop_advlock_args *);
  87 static int smbfs_getextattr(struct vop_getextattr_args *ap);
  88
  89 struct vop_ops smbfs_vnode_vops = {
  90         .vop_default =          vop_defaultop,
  91         .vop_access =           smbfs_access,
  92         .vop_advlock =          smbfs_advlock,
  93         .vop_bmap =             smbfs_bmap,
  94         .vop_close =            smbfs_closel,
  95         .vop_old_create =       smbfs_create,
  96         .vop_fsync =            smbfs_fsync,
  97         .vop_getattr =          smbfs_getattr,
  98         .vop_getpages =         smbfs_getpages,
  99         .vop_inactive =         smbfs_inactive,
 100         .vop_ioctl =            smbfs_ioctl,
 101         .vop_old_link =         smbfs_link,
 102         .vop_old_lookup =       smbfs_lookup,
 103         .vop_old_mkdir =        smbfs_mkdir,
 104         .vop_old_mknod =        smbfs_mknod,
 105         .vop_open =             smbfs_open,
 106         .vop_pathconf =         smbfs_pathconf,
 107         .vop_print =            smbfs_print,
 108         .vop_putpages =         smbfs_putpages,
 109         .vop_read =             smbfs_read,
 110         .vop_readdir =          smbfs_readdir,
 111         .vop_reclaim =          smbfs_reclaim,
 112         .vop_old_remove =       smbfs_remove,
 113         .vop_old_rename =       smbfs_rename,
 114         .vop_old_rmdir =        smbfs_rmdir,
 115         .vop_setattr =          smbfs_setattr,
 116         .vop_strategy =         smbfs_strategy,
 117         .vop_old_symlink =      smbfs_symlink,
 118         .vop_write =            smbfs_write,
 119         .vop_getextattr =       smbfs_getextattr
 120 /*      .vop_setextattr =       smbfs_setextattr */
 121 };
 122
 123 /*
 124  * smbfs_access(struct vnode *a_vp, int a_mode, struct ucred *a_cred)
 125  */
 126 static int
 127 smbfs_access(struct vop_access_args *ap)
 128 {
 129         struct vnode *vp = ap->a_vp;
 130         struct ucred *cred = ap->a_cred;
 131         u_int mode = ap->a_mode;
 132         struct smbmount *smp = VTOSMBFS(vp);
 133         int error = 0;
 134
 135         SMBVDEBUG("\n");
 136         if ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
 137                 switch (vp->v_type) {
 138                     case VREG: case VDIR: case VLNK:
 139                         return EROFS;
 140                     default:
 141                         break;
 142                 }
 143         }
 144         if (cred->cr_uid == 0)
 145                 return 0;
 146         if (cred->cr_uid != smp->sm_args.uid) {
 147                 mode >>= 3;
 148                 if (!groupmember(smp->sm_args.gid, cred))
 149                         mode >>= 3;
 150         }
 151         error = (((vp->v_type == VREG) ? smp->sm_args.file_mode : smp->sm_args.dir_mode) & mode) == mode ? 0 : EACCES;
 152         return error;
 153 }
 154
 155 /*
 156  * smbfs_open(struct vnode *a_vp, int a_mode, struct ucred *a_cred,
 157  *            struct file *a_fp)
 158  */
 159 /* ARGSUSED */
 160 static int
 161 smbfs_open(struct vop_open_args *ap)
 162 {
 163         struct vnode *vp = ap->a_vp;
 164         struct smbnode *np = VTOSMB(vp);
 165         struct smb_cred scred;
 166         struct vattr vattr;
 167         int mode = ap->a_mode;
 168         int error, accmode;
 169
 170         SMBVDEBUG("%s,%d\n", np->n_name, np->n_opencount);
 171         if (vp->v_type != VREG && vp->v_type != VDIR) {
 172                 SMBFSERR("open eacces vtype=%d\n", vp->v_type);
 173                 return EACCES;
 174         }
 175         if (vp->v_type == VDIR) {
 176                 if (np->n_opencount == 0)
 177                         np->n_cached_cred = crhold(ap->a_cred);
 178                 np->n_opencount++;
 179                 return (vop_stdopen(ap));
 180         }
 181         if (np->n_flag & NMODIFIED) {
 182                 if ((error = smbfs_vinvalbuf(vp, V_SAVE, 1)) == EINTR)
 183                         return error;
 184                 smbfs_attr_cacheremove(vp);
 185                 error = VOP_GETATTR(vp, &vattr);
 186                 if (error)
 187                         return error;
 188                 np->n_mtime.tv_sec = vattr.va_mtime.tv_sec;
 189         } else {
 190                 error = VOP_GETATTR(vp, &vattr);
 191                 if (error)
 192                         return error;
 193                 if (np->n_mtime.tv_sec != vattr.va_mtime.tv_sec) {
 194                         error = smbfs_vinvalbuf(vp, V_SAVE, 1);
 195                         if (error == EINTR)
 196                                 return error;
 197                         np->n_mtime.tv_sec = vattr.va_mtime.tv_sec;
 198                 }
 199         }
 200         if (np->n_opencount) {
 201                 np->n_opencount++;
 202                 return (vop_stdopen(ap));
 203         }
 204         accmode = SMB_AM_OPENREAD;
 205         if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
 206                 accmode = SMB_AM_OPENRW;
 207         smb_makescred(&scred, curthread, ap->a_cred);
 208         error = smbfs_smb_open(np, accmode, &scred);
 209         if (error) {
 210                 if (mode & FWRITE)
 211                         return EACCES;
 212                 accmode = SMB_AM_OPENREAD;
 213                 error = smbfs_smb_open(np, accmode, &scred);
 214         }
 215         if (!error) {
 216                 np->n_cached_cred = crhold(ap->a_cred);
 217                 np->n_opencount++;
 218         }
 219         smbfs_attr_cacheremove(vp);
 220         if (error == 0)
 221                 vop_stdopen(ap);
 222         return error;
 223 }
 224
 225 static int
 226 smbfs_closel(struct vop_close_args *ap)
 227 {
 228         struct vnode *vp = ap->a_vp;
 229         struct smbnode *np = VTOSMB(vp);
 230         struct smb_cred scred;
 231         struct vattr vattr;
 232         int error;
 233
 234         SMBVDEBUG("name=%s, pid=%d, c=%d\n",np->n_name, p->p_pid, np->n_opencount);
 235
 236         smb_makescred(&scred, curthread, proc0.p_ucred);
 237         error = 0;
 238
 239         if (np->n_opencount == 0) {
 240                 if (vp->v_type != VDIR)
 241                         SMBERROR("Negative opencount\n");
 242                 goto done;
 243         }
 244         np->n_opencount--;
 245         if (vp->v_type == VDIR) {
 246                 if (np->n_opencount)
 247                         goto done;
 248                 if (np->n_dirseq) {
 249                         smbfs_findclose(np->n_dirseq, &scred);
 250                         np->n_dirseq = NULL;
 251                 }
 252         } else {
 253                 error = smbfs_vinvalbuf(vp, V_SAVE, 1);
 254                 if (np->n_opencount)
 255                         goto done;
 256                 VOP_GETATTR(vp, &vattr);
 257                 error = smbfs_smb_close(np->n_mount->sm_share, np->n_fid,
 258                            &np->n_mtime, &scred);
 259         }
 260         crfree(np->n_cached_cred);
 261         np->n_cached_cred = NULL;
 262         smbfs_attr_cacheremove(vp);
 263 done:
 264         vop_stdclose(ap);
 265         return error;
 266 }
 267
 268 /*
 269  * smbfs_getattr call from vfs.
 270  *
 271  * smbfs_getattr(struct vnode *a_vp, struct vattr *a_vap)
 272  */
 273 static int
 274 smbfs_getattr(struct vop_getattr_args *ap)
 275 {
 276         struct vnode *vp = ap->a_vp;
 277         struct smbnode *np = VTOSMB(vp);
 278         struct vattr *va=ap->a_vap;
 279         struct smbfattr fattr;
 280         struct smb_cred scred;
 281         u_quad_t oldsize;
 282         int error;
 283
 284         SMBVDEBUG("%lx: '%s' %d\n", (long)vp, np->n_name, (vp->v_flag & VROOT) != 0);
 285         error = smbfs_attr_cachelookup(vp, va);
 286         if (!error)
 287                 return 0;
 288         SMBVDEBUG("not in the cache\n");
 289         smb_makescred(&scred, curthread, proc0.p_ucred);
 290         oldsize = np->n_size;
 291         error = smbfs_smb_lookup(np, NULL, 0, &fattr, &scred);
 292         if (error) {
 293                 SMBVDEBUG("error %d\n", error);
 294                 return error;
 295         }
 296         smbfs_attr_cacheenter(vp, &fattr);
 297         smbfs_attr_cachelookup(vp, va);
 298         if (np->n_opencount)
 299                 np->n_size = oldsize;
 300         return 0;
 301 }
 302
 303 /*
 304  * smbfs_setattr(struct vnode *a_vp, struct vattr *a_vap, struct ucred *a_cred)
 305  */
 306 static int
 307 smbfs_setattr(struct vop_setattr_args *ap)
 308 {
 309         struct vnode *vp = ap->a_vp;
 310         struct smbnode *np = VTOSMB(vp);
 311         struct vattr *vap = ap->a_vap;
 312         struct timespec *mtime, *atime;
 313         struct smb_cred scred;
 314         struct smb_share *ssp = np->n_mount->sm_share;
 315         struct smb_vc *vcp = SSTOVC(ssp);
 316         u_quad_t tsize = 0;
 317         int isreadonly, doclose, error = 0;
 318
 319         SMBVDEBUG("\n");
 320         if (vap->va_flags != VNOVAL)
 321                 return EOPNOTSUPP;
 322         isreadonly = (vp->v_mount->mnt_flag & MNT_RDONLY);
 323         /*
 324          * Disallow write attempts if the filesystem is mounted read-only.
 325          */
 326         if ((vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL ||
 327              vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL ||
 328              vap->va_mode != (mode_t)VNOVAL) && isreadonly)
 329                 return EROFS;
 330         smb_makescred(&scred, curthread, ap->a_cred);
 331         if (vap->va_size != VNOVAL) {
 332                 switch (vp->v_type) {
 333                     case VDIR:
 334                         return EISDIR;
 335                     case VREG:
 336                         break;
 337                     default:
 338                         return EINVAL;
 339                 };
 340                 if (isreadonly)
 341                         return EROFS;
 342                 doclose = 0;
 343                 vnode_pager_setsize(vp, (u_long)vap->va_size);
 344                 tsize = np->n_size;
 345                 np->n_size = vap->va_size;
 346                 if (np->n_opencount == 0) {
 347                         error = smbfs_smb_open(np, SMB_AM_OPENRW, &scred);
 348                         if (error == 0)
 349                                 doclose = 1;
 350                 }
 351                 if (error == 0)
 352                         error = smbfs_smb_setfsize(np, vap->va_size, &scred);
 353                 if (doclose)
 354                         smbfs_smb_close(ssp, np->n_fid, NULL, &scred);
 355                 if (error) {
 356                         np->n_size = tsize;
 357                         vnode_pager_setsize(vp, (u_long)tsize);
 358                         return error;
 359                 }
 360         }
 361         mtime = atime = NULL;
 362         if (vap->va_mtime.tv_sec != VNOVAL)
 363                 mtime = &vap->va_mtime;
 364         if (vap->va_atime.tv_sec != VNOVAL)
 365                 atime = &vap->va_atime;
 366         if (mtime != atime) {
 367                 if (ap->a_cred->cr_uid != VTOSMBFS(vp)->sm_args.uid &&
 368                     (error = suser_cred(ap->a_cred, PRISON_ROOT)) &&
 369                     ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
 370                     (error = VOP_ACCESS(vp, VWRITE, ap->a_cred))))
 371                         return (error);
 372 #if 0
 373                 if (mtime == NULL)
 374                         mtime = &np->n_mtime;
 375                 if (atime == NULL)
 376                         atime = &np->n_atime;
 377 #endif
 378                 /*
 379                  * If file is opened, then we can use handle based calls.
 380                  * If not, use path based ones.
 381                  */
 382                 if (np->n_opencount == 0) {
 383                         if (vcp->vc_flags & SMBV_WIN95) {
 384                                 error = VOP_OPEN(vp, FWRITE, ap->a_cred, NULL);
 385                                 if (!error) {
 386 /*                              error = smbfs_smb_setfattrNT(np, 0, mtime, atime, &scred);
 387                                 VOP_GETATTR(vp, &vattr);*/
 388                                 if (mtime)
 389                                         np->n_mtime = *mtime;
 390                                 VOP_CLOSE(vp, FWRITE);
 391                                 }
 392                         } else if ((vcp->vc_sopt.sv_caps & SMB_CAP_NT_SMBS)) {
 393                                 error = smbfs_smb_setptime2(np, mtime, atime, 0, &scred);
 394 /*                              error = smbfs_smb_setpattrNT(np, 0, mtime, atime, &scred);*/
 395                         } else if (SMB_DIALECT(vcp) >= SMB_DIALECT_LANMAN2_0) {
 396                                 error = smbfs_smb_setptime2(np, mtime, atime, 0, &scred);
 397                         } else {
 398                                 error = smbfs_smb_setpattr(np, 0, mtime, &scred);
 399                         }
 400                 } else {
 401                         if (vcp->vc_sopt.sv_caps & SMB_CAP_NT_SMBS) {
 402                                 error = smbfs_smb_setfattrNT(np, 0, mtime, atime, &scred);
 403                         } else if (SMB_DIALECT(vcp) >= SMB_DIALECT_LANMAN1_0) {
 404                                 error = smbfs_smb_setftime(np, mtime, atime, &scred);
 405                         } else {
 406                                 /*
 407                                  * I have no idea how to handle this for core
 408                                  * level servers. The possible solution is to
 409                                  * update mtime after file is closed.
 410                                  */
 411                                  SMBERROR("can't update times on an opened file\n");
 412                         }
 413                 }
 414         }
 415         /*
 416          * Invalidate attribute cache in case if server doesn't set
 417          * required attributes.
 418          */
 419         smbfs_attr_cacheremove(vp);     /* invalidate cache */
 420         VOP_GETATTR(vp, vap);
 421         np->n_mtime.tv_sec = vap->va_mtime.tv_sec;
 422         return error;
 423 }
 424 /*
 425  * smbfs_read call.
 426  *
 427  * smbfs_read(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
 428  *            struct ucred *a_cred)
 429  */
 430 static int
 431 smbfs_read(struct vop_read_args *ap)
 432 {
 433         struct vnode *vp = ap->a_vp;
 434         struct uio *uio = ap->a_uio;
 435
 436         SMBVDEBUG("\n");
 437         if (vp->v_type != VREG && vp->v_type != VDIR)
 438                 return EPERM;
 439         return smbfs_readvnode(vp, uio, ap->a_cred);
 440 }
 441
 442 /*
 443  * smbfs_write(struct vnode *a_vp, struct uio *a_uio, int a_ioflag,
 444  *             struct ucred *a_cred)
 445  */
 446 static int
 447 smbfs_write(struct vop_write_args *ap)
 448 {
 449         struct vnode *vp = ap->a_vp;
 450         struct uio *uio = ap->a_uio;
 451
 452         SMBVDEBUG("%d,ofs=%d,sz=%d\n",vp->v_type, (int)uio->uio_offset, uio->uio_resid);
 453         if (vp->v_type != VREG)
 454                 return (EPERM);
 455         return smbfs_writevnode(vp, uio, ap->a_cred,ap->a_ioflag);
 456 }
 457 /*
 458  * smbfs_create call
 459  * Create a regular file. On entry the directory to contain the file being
 460  * created is locked.  We must release before we return.
 461  *
 462  * smbfs_create(struct vnode *a_dvp, struct vnode **a_vpp,
 463  *              struct componentname *a_cnp, struct vattr *a_vap)
 464  */
 465 static int
 466 smbfs_create(struct vop_old_create_args *ap)
 467 {
 468         struct vnode *dvp = ap->a_dvp;
 469         struct vattr *vap = ap->a_vap;
 470         struct vnode **vpp=ap->a_vpp;
 471         struct componentname *cnp = ap->a_cnp;
 472         struct smbnode *dnp = VTOSMB(dvp);
 473         struct vnode *vp;
 474         struct vattr vattr;
 475         struct smbfattr fattr;
 476         struct smb_cred scred;
 477         char *name = cnp->cn_nameptr;
 478         int nmlen = cnp->cn_namelen;
 479         int error;
 480
 481
 482         SMBVDEBUG("\n");
 483         *vpp = NULL;
 484         if (vap->va_type != VREG)
 485                 return EOPNOTSUPP;
 486         if ((error = VOP_GETATTR(dvp, &vattr)))
 487                 return error;
 488         smb_makescred(&scred, cnp->cn_td, cnp->cn_cred);
 489
 490         error = smbfs_smb_create(dnp, name, nmlen, &scred);
 491         if (error)
 492                 return error;
 493         error = smbfs_smb_lookup(dnp, name, nmlen, &fattr, &scred);
 494         if (error)
 495                 return error;
 496         error = smbfs_nget(VTOVFS(dvp), dvp, name, nmlen, &fattr, &vp);
 497         if (error)
 498                 return error;
 499         *vpp = vp;
 500         return error;
 501 }
 502
 503 /*
 504  * smbfs_remove(struct vnode *a_dvp, struct vnode *a_vp,
 505  *              struct componentname *a_cnp)
 506  */
 507 static int
 508 smbfs_remove(struct vop_old_remove_args *ap)
 509 {
 510         struct vnode *vp = ap->a_vp;
 511 /*      struct vnode *dvp = ap->a_dvp;*/
 512         struct componentname *cnp = ap->a_cnp;
 513         struct smbnode *np = VTOSMB(vp);
 514         struct smb_cred scred;
 515         int error;
 516
 517         if (vp->v_type == VDIR || np->n_opencount || vp->v_sysref.refcnt > 1)
 518                 return EPERM;
 519         smb_makescred(&scred, cnp->cn_td, cnp->cn_cred);
 520         error = smbfs_smb_delete(np, &scred);
 521         return error;
 522 }
 523
 524 /*
 525  * smbfs_file rename call
 526  *
 527  * smbfs_rename(struct vnode *a_fdvp, struct vnode *a_fvp,
 528  *              struct componentname *a_fcnp, struct vnode *a_tdvp,
 529  *              struct vnode *a_tvp, struct componentname *a_tcnp)
 530  */
 531 static int
 532 smbfs_rename(struct vop_old_rename_args *ap)
 533 {
 534         struct vnode *fvp = ap->a_fvp;
 535         struct vnode *tvp = ap->a_tvp;
 536         struct vnode *fdvp = ap->a_fdvp;
 537         struct vnode *tdvp = ap->a_tdvp;
 538         struct componentname *tcnp = ap->a_tcnp;
 539 /*      struct componentname *fcnp = ap->a_fcnp;*/
 540         struct smb_cred scred;
 541         u_int16_t flags = 6;
 542         int error=0;
 543
 544         /* Check for cross-device rename */
 545         if ((fvp->v_mount != tdvp->v_mount) ||
 546             (tvp && (fvp->v_mount != tvp->v_mount))) {
 547                 error = EXDEV;
 548                 goto out;
 549         }
 550
 551         if (tvp && tvp->v_sysref.refcnt > 1) {
 552                 error = EBUSY;
 553                 goto out;
 554         }
 555         flags = 0x10;                   /* verify all writes */
 556         if (fvp->v_type == VDIR) {
 557                 flags |= 2;
 558         } else if (fvp->v_type == VREG) {
 559                 flags |= 1;
 560         } else {
 561                 error = EINVAL;
 562                 goto out;
 563         }
 564         smb_makescred(&scred, tcnp->cn_td, tcnp->cn_cred);
 565         /*
 566          * It seems that Samba doesn't implement SMB_COM_MOVE call...
 567          */
 568 #ifdef notnow
 569         if (SMB_DIALECT(SSTOCN(smp->sm_share)) >= SMB_DIALECT_LANMAN1_0) {
 570                 error = smbfs_smb_move(VTOSMB(fvp), VTOSMB(tdvp),
 571                     tcnp->cn_nameptr, tcnp->cn_namelen, flags, &scred);
 572         } else
 573 #endif
 574         {
 575                 /*
 576                  * We have to do the work atomicaly
 577                  */
 578                 if (tvp && tvp != fvp) {
 579                         error = smbfs_smb_delete(VTOSMB(tvp), &scred);
 580                         if (error)
 581                                 goto out_cacherem;
 582                 }
 583                 error = smbfs_smb_rename(VTOSMB(fvp), VTOSMB(tdvp),
 584                     tcnp->cn_nameptr, tcnp->cn_namelen, &scred);
 585         }
 586
 587 out_cacherem:
 588         smbfs_attr_cacheremove(fdvp);
 589         smbfs_attr_cacheremove(tdvp);
 590 out:
 591         if (tdvp == tvp)
 592                 vrele(tdvp);
 593         else
 594                 vput(tdvp);
 595         if (tvp)
 596                 vput(tvp);
 597         vrele(fdvp);
 598         vrele(fvp);
 599 #ifdef possible_mistake
 600 #error x
 601         vgone_vxlocked(fvp);
 602         if (tvp)
 603                 vgone_vxlocked(tvp);
 604 #endif
 605         return error;
 606 }
 607
 608 /*
 609  * somtime it will come true...
 610  *
 611  * smbfs_link(struct vnode *a_tdvp, struct vnode *a_vp,
 612  *            struct componentname *a_cnp)
 613  */
 614 static int
 615 smbfs_link(struct vop_old_link_args *ap)
 616 {
 617         return EOPNOTSUPP;
 618 }
 619
 620 /*
 621  * smbfs_symlink link create call.
 622  * Sometime it will be functional...
 623  *
 624  * smbfs_symlink(struct vnode *a_dvp, struct vnode **a_vpp,
 625  *               struct componentname *a_cnp, struct vattr *a_vap,
 626  *               char *a_target)
 627  */
 628 static int
 629 smbfs_symlink(struct vop_old_symlink_args *ap)
 630 {
 631         return EOPNOTSUPP;
 632 }
 633
 634 static int
 635 smbfs_mknod(struct vop_old_mknod_args *ap)
 636 {
 637         return EOPNOTSUPP;
 638 }
 639
 640 /*
 641  * smbfs_mkdir(struct vnode *a_dvp, struct vnode **a_vpp,
 642  *              struct componentname *a_cnp, struct vattr *a_vap)
 643  */
 644 static int
 645 smbfs_mkdir(struct vop_old_mkdir_args *ap)
 646 {
 647         struct vnode *dvp = ap->a_dvp;
 648 /*      struct vattr *vap = ap->a_vap;*/
 649         struct vnode *vp;
 650         struct componentname *cnp = ap->a_cnp;
 651         struct smbnode *dnp = VTOSMB(dvp);
 652         struct vattr vattr;
 653         struct smb_cred scred;
 654         struct smbfattr fattr;
 655         char *name = cnp->cn_nameptr;
 656         int len = cnp->cn_namelen;
 657         int error;
 658
 659         if ((error = VOP_GETATTR(dvp, &vattr))) {
 660                 return error;
 661         }
 662         if ((name[0] == '.') && ((len == 1) || ((len == 2) && (name[1] == '.'))))
 663                 return EEXIST;
 664         smb_makescred(&scred, cnp->cn_td, cnp->cn_cred);
 665         error = smbfs_smb_mkdir(dnp, name, len, &scred);
 666         if (error)
 667                 return error;
 668         error = smbfs_smb_lookup(dnp, name, len, &fattr, &scred);
 669         if (error)
 670                 return error;
 671         error = smbfs_nget(VTOVFS(dvp), dvp, name, len, &fattr, &vp);
 672         if (error)
 673                 return error;
 674         *ap->a_vpp = vp;
 675         return 0;
 676 }
 677
 678 /*
 679  * smbfs_remove directory call
 680  *
 681  * smbfs_rmdir(struct vnode *a_dvp, struct vnode *a_vp,
 682  *              struct componentname *a_cnp)
 683  */
 684 static int
 685 smbfs_rmdir(struct vop_old_rmdir_args *ap)
 686 {
 687         struct vnode *vp = ap->a_vp;
 688         struct vnode *dvp = ap->a_dvp;
 689         struct componentname *cnp = ap->a_cnp;
 690 /*      struct smbmount *smp = VTOSMBFS(vp);*/
 691         struct smbnode *dnp = VTOSMB(dvp);
 692         struct smbnode *np = VTOSMB(vp);
 693         struct smb_cred scred;
 694         int error;
 695
 696         if (dvp == vp)
 697                 return EINVAL;
 698
 699         smb_makescred(&scred, cnp->cn_td, cnp->cn_cred);
 700         error = smbfs_smb_rmdir(np, &scred);
 701         dnp->n_flag |= NMODIFIED;
 702         smbfs_attr_cacheremove(dvp);
 703         return error;
 704 }
 705
 706 /*
 707  * smbfs_readdir call
 708  *
 709  * smbfs_readdir(struct vnode *a_vp, struct uio *a_uio, struct ucred *a_cred,
 710  *               int *a_eofflag, off_t *a_cookies, int a_ncookies)
 711  */
 712 static int
 713 smbfs_readdir(struct vop_readdir_args *ap)
 714 {
 715         struct vnode *vp = ap->a_vp;
 716         struct uio *uio = ap->a_uio;
 717         int error;
 718
 719         if (vp->v_type != VDIR)
 720                 return (EPERM);
 721 #ifdef notnow
 722         if (ap->a_ncookies) {
 723                 kprintf("smbfs_readdir: no support for cookies now...");
 724                 return (EOPNOTSUPP);
 725         }
 726 #endif
 727         if ((error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY)) == 0) {
 728                 error = smbfs_readvnode(vp, uio, ap->a_cred);
 729                 vn_unlock(vp);
 730         }
 731         return error;
 732 }
 733
 734 /*
 735  * smbfs_fsync(struct vnode *a_vp, int a_waitfor)
 736  */
 737 /* ARGSUSED */
 738 static int
 739 smbfs_fsync(struct vop_fsync_args *ap)
 740 {
 741 /*      return (smb_flush(ap->a_vp, ap->a_waitfor, curthread, 1));*/
 742     return (0);
 743 }
 744
 745 /*
 746  * smbfs_print(struct vnode *a_vp)
 747  */
 748 static int
 749 smbfs_print(struct vop_print_args *ap)
 750 {
 751         struct vnode *vp = ap->a_vp;
 752         struct smbnode *np = VTOSMB(vp);
 753
 754         if (np == NULL) {
 755                 kprintf("no smbnode data\n");
 756                 return (0);
 757         }
 758         kprintf("tag VT_SMBFS, name = %s, parent = %p, opencount = %d",
 759             np->n_name, np->n_parent ? np->n_parent : NULL,
 760             np->n_opencount);
 761         lockmgr_printinfo(&vp->v_lock);
 762         kprintf("\n");
 763         return (0);
 764 }
 765
 766 /*
 767  * smbfs_pathconf(struct vnode *vp, int name, register_t *retval)
 768  */
 769 static int
 770 smbfs_pathconf(struct vop_pathconf_args *ap)
 771 {
 772         struct smbmount *smp = VFSTOSMBFS(VTOVFS(ap->a_vp));
 773         struct smb_vc *vcp = SSTOVC(smp->sm_share);
 774         register_t *retval = ap->a_retval;
 775         int error = 0;
 776
 777         switch (ap->a_name) {
 778             case _PC_LINK_MAX:
 779                 *retval = 0;
 780                 break;
 781             case _PC_NAME_MAX:
 782                 *retval = (vcp->vc_hflags2 & SMB_FLAGS2_KNOWS_LONG_NAMES) ? 255 : 12;
 783                 break;
 784             case _PC_PATH_MAX:
 785                 *retval = 800;  /* XXX: a correct one ? */
 786                 break;
 787             default:
 788                 error = EINVAL;
 789         }
 790         return error;
 791 }
 792
 793 /*
 794  * smbfs_strategy(struct vnode *a_vp, struct bio *a_bio)
 795  */
 796 static int
 797 smbfs_strategy(struct vop_strategy_args *ap)
 798 {
 799         struct bio *bio = ap->a_bio;
 800         struct buf *bp = bio->bio_buf;
 801         struct thread *td = NULL;
 802         int error = 0;
 803
 804         SMBVDEBUG("\n");
 805         if ((bp->b_flags & B_ASYNC) == 0)
 806                 td = curthread;         /* XXX */
 807
 808         if ((bp->b_flags & B_ASYNC) == 0 )
 809                 error = smbfs_doio(ap->a_vp, bio, proc0.p_ucred, td);
 810         return error;
 811 }
 812
 813 /*
 814  * smbfs_bmap(struct vnode *a_vp, off_t a_loffset,
 815  *            off_t *a_doffsetp, int *a_runp, int *a_runb)
 816  */
 817 static int
 818 smbfs_bmap(struct vop_bmap_args *ap)
 819 {
 820         if (ap->a_doffsetp != NULL)
 821                 *ap->a_doffsetp = ap->a_loffset;
 822         if (ap->a_runp != NULL)
 823                 *ap->a_runp = 0;
 824         if (ap->a_runb != NULL)
 825                 *ap->a_runb = 0;
 826         return (0);
 827 }
 828
 829 /*
 830  * smbfs_ioctl(struct vnode *a_vp, u_long a_command, caddr_t a_data,
 831  *              int fflag, struct ucred *cred, struct proc *p)
 832  */
 833 int
 834 smbfs_ioctl(struct vop_ioctl_args *ap)
 835 {
 836         return EINVAL;
 837 }
 838
 839 static char smbfs_atl[] = "rhsvda";
 840
 841 /*
 842  * smbfs_getextattr(struct vnode *a_vp, char *a_name, struct uio *a_uio,
 843  *              struct ucred *a_cred)
 844  */
 845 static int
 846 smbfs_getextattr(struct vop_getextattr_args *ap)
 847 {
 848         struct vnode *vp = ap->a_vp;
 849         struct ucred *cred = ap->a_cred;
 850         struct uio *uio = ap->a_uio;
 851         const char *name = ap->a_name;
 852         struct smbnode *np = VTOSMB(vp);
 853         struct vattr vattr;
 854         char buf[10];
 855         int i, attr, error;
 856
 857         error = VOP_ACCESS(vp, VREAD, cred);
 858         if (error)
 859                 return error;
 860         error = VOP_GETATTR(vp, &vattr);
 861         if (error)
 862                 return error;
 863         if (strcmp(name, "dosattr") == 0) {
 864                 attr = np->n_dosattr;
 865                 for (i = 0; i < 6; i++, attr >>= 1)
 866                         buf[i] = (attr & 1) ? smbfs_atl[i] : '-';
 867                 buf[i] = 0;
 868                 error = uiomove(buf, i, uio);
 869
 870         } else
 871                 error = EINVAL;
 872         return error;
 873 }
 874
 875 /*
 876  * Since we expected to support F_GETLK (and SMB protocol has no such function),
 877  * it is necessary to use lf_advlock(). It would be nice if this function had
 878  * a callback mechanism because it will help to improve a level of consistency.
 879  *
 880  * smbfs_advlock(struct vnode *a_vp, caddr_t a_id, int a_op,
 881  *               struct flock *a_fl, int a_flags)
 882  */
 883 int
 884 smbfs_advlock(struct vop_advlock_args *ap)
 885 {
 886         struct vnode *vp = ap->a_vp;
 887         struct smbnode *np = VTOSMB(vp);
 888         struct flock *fl = ap->a_fl;
 889         caddr_t id = (caddr_t)1 /* ap->a_id */;
 890 /*      int flags = ap->a_flags;*/
 891         struct thread *td = curthread;          /* XXX */
 892         struct smb_cred scred;
 893         off_t start, end, size;
 894         int error, lkop;
 895
 896         if (vp->v_type == VDIR) {
 897                 /*
 898                  * SMB protocol have no support for directory locking.
 899                  * Although locks can be processed on local machine, I don't
 900                  * think that this is a good idea, because some programs
 901                  * can work wrong assuming directory is locked. So, we just
 902                  * return 'operation not supported
 903                  */
 904                  return EOPNOTSUPP;
 905         }
 906         size = np->n_size;
 907         switch (fl->l_whence) {
 908             case SEEK_SET:
 909             case SEEK_CUR:
 910                 start = fl->l_start;
 911                 break;
 912             case SEEK_END:
 913                 start = fl->l_start + size;
 914             default:
 915                 return EINVAL;
 916         }
 917         if (start < 0)
 918                 return EINVAL;
 919         if (fl->l_len == 0)
 920                 end = -1;
 921         else {
 922                 end = start + fl->l_len - 1;
 923                 if (end < start)
 924                         return EINVAL;
 925         }
 926         smb_makescred(&scred, td, td->td_proc ? td->td_proc->p_ucred : NULL);
 927         switch (ap->a_op) {
 928             case F_SETLK:
 929                 switch (fl->l_type) {
 930                     case F_WRLCK:
 931                         lkop = SMB_LOCK_EXCL;
 932                         break;
 933                     case F_RDLCK:
 934                         lkop = SMB_LOCK_SHARED;
 935                         break;
 936                     case F_UNLCK:
 937                         lkop = SMB_LOCK_RELEASE;
 938                         break;
 939                     default:
 940                         return EINVAL;
 941                 }
 942                 error = lf_advlock(ap, &np->n_lockf, size);
 943                 if (error)
 944                         break;
 945                 lkop = SMB_LOCK_EXCL;
 946                 error = smbfs_smb_lock(np, lkop, id, start, end, &scred);
 947                 if (error) {
 948                         ap->a_op = F_UNLCK;
 949                         lf_advlock(ap, &np->n_lockf, size);
 950                 }
 951                 break;
 952             case F_UNLCK:
 953                 lf_advlock(ap, &np->n_lockf, size);
 954                 error = smbfs_smb_lock(np, SMB_LOCK_RELEASE, id, start, end, &scred);
 955                 break;
 956             case F_GETLK:
 957                 error = lf_advlock(ap, &np->n_lockf, size);
 958                 break;
 959             default:
 960                 return EINVAL;
 961         }
 962         return error;
 963 }
 964
 965 static int
 966 smbfs_pathcheck(struct smbmount *smp, const char *name, int nmlen, int nameiop)
 967 {
 968         static const char *badchars = "*/:<>;?";
 969         static const char *badchars83 = " +|,";
 970         const char *cp;
 971         int i, error;
 972
 973         /*
 974          * Backslash characters, being a path delimiter, are prohibited
 975          * within a path component even for LOOKUP operations.
 976          */
 977         if (index(name, '\\') != NULL)
 978                 return ENOENT;
 979
 980         if (nameiop == NAMEI_LOOKUP)
 981                 return 0;
 982         error = ENOENT;
 983         if (SMB_DIALECT(SSTOVC(smp->sm_share)) < SMB_DIALECT_LANMAN2_0) {
 984                 /*
 985                  * Name should conform 8.3 format
 986                  */
 987                 if (nmlen > 12)
 988                         return ENAMETOOLONG;
 989                 cp = index(name, '.');
 990                 if (cp == NULL)
 991                         return error;
 992                 if (cp == name || (cp - name) > 8)
 993                         return error;
 994                 cp = index(cp + 1, '.');
 995                 if (cp != NULL)
 996                         return error;
 997                 for (cp = name, i = 0; i < nmlen; i++, cp++)
 998                         if (index(badchars83, *cp) != NULL)
 999                                 return error;
1000         }
1001         for (cp = name, i = 0; i < nmlen; i++, cp++)
1002                 if (index(badchars, *cp) != NULL)
1003                         return error;
1004         return 0;
1005 }
1006
1007 /*
1008  * Things go even weird without fixed inode numbers...
1009  *
1010  * smbfs_lookup(struct vnode *a_dvp, struct vnode **a_vpp,
1011  *              struct componentname *a_cnp)
1012  */
1013 int
1014 smbfs_lookup(struct vop_old_lookup_args *ap)
1015 {
1016         struct componentname *cnp = ap->a_cnp;
1017         struct thread *td = cnp->cn_td;
1018         struct vnode *dvp = ap->a_dvp;
1019         struct vnode **vpp = ap->a_vpp;
1020         struct vnode *vp;
1021         struct smbmount *smp;
1022         struct mount *mp = dvp->v_mount;
1023         struct smbnode *dnp;
1024         struct smbfattr fattr, *fap;
1025         struct smb_cred scred;
1026         char *name = cnp->cn_nameptr;
1027         int flags = cnp->cn_flags;
1028         int nameiop = cnp->cn_nameiop;
1029         int nmlen = cnp->cn_namelen;
1030         int lockparent, wantparent, error, isdot;
1031
1032         SMBVDEBUG("\n");
1033         cnp->cn_flags &= ~CNP_PDIRUNLOCK;
1034         *vpp = NULL;
1035         if (dvp->v_type != VDIR)
1036                 return ENOTDIR;
1037         if ((flags & CNP_ISDOTDOT) && (dvp->v_flag & VROOT)) {
1038                 SMBFSERR("invalid '..'\n");
1039                 return EIO;
1040         }
1041 #ifdef SMB_VNODE_DEBUG
1042         {
1043                 char *cp, c;
1044
1045                 cp = name + nmlen;
1046                 c = *cp;
1047                 *cp = 0;
1048                 SMBVDEBUG("%d '%s' in '%s' id=d\n", nameiop, name,
1049                         VTOSMB(dvp)->n_name);
1050                 *cp = c;
1051         }
1052 #endif
1053         if ((mp->mnt_flag & MNT_RDONLY) && nameiop != NAMEI_LOOKUP)
1054                 return EROFS;
1055         if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred)) != 0)
1056                 return error;
1057         lockparent = flags & CNP_LOCKPARENT;
1058         wantparent = flags & (CNP_LOCKPARENT | CNP_WANTPARENT);
1059         smp = VFSTOSMBFS(mp);
1060         dnp = VTOSMB(dvp);
1061         isdot = (nmlen == 1 && name[0] == '.');
1062
1063         error = smbfs_pathcheck(smp, cnp->cn_nameptr, cnp->cn_namelen, nameiop);
1064
1065         if (error)
1066                 return ENOENT;
1067
1068         error = 0;
1069         smb_makescred(&scred, td, cnp->cn_cred);
1070         fap = &fattr;
1071         if (flags & CNP_ISDOTDOT) {
1072                 error = smbfs_smb_lookup(VTOSMB(dnp->n_parent), NULL, 0, fap,
1073                     &scred);
1074                 SMBVDEBUG("result of dotdot lookup: %d\n", error);
1075         } else {
1076                 fap = &fattr;
1077                 error = smbfs_smb_lookup(dnp, name, nmlen, fap, &scred);
1078 /*              if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.')*/
1079                 SMBVDEBUG("result of smbfs_smb_lookup: %d\n", error);
1080         }
1081         if (error && error != ENOENT)
1082                 return error;
1083         if (error) {                    /* entry not found */
1084                 /*
1085                  * Handle RENAME or CREATE case...
1086                  */
1087                 if ((nameiop == NAMEI_CREATE || nameiop == NAMEI_RENAME) && wantparent) {
1088                         error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
1089                         if (error)
1090                                 return error;
1091                         if (!lockparent) {
1092                                 vn_unlock(dvp);
1093                                 cnp->cn_flags |= CNP_PDIRUNLOCK;
1094                         }
1095                         return (EJUSTRETURN);
1096                 }
1097                 return ENOENT;
1098         }/* else {
1099                 SMBVDEBUG("Found entry %s with id=%d\n", fap->entryName, fap->dirEntNum);
1100         }*/
1101         /*
1102          * handle DELETE case ...
1103          */
1104         if (nameiop == NAMEI_DELETE) {  /* delete last component */
1105                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
1106                 if (error)
1107                         return error;
1108                 if (isdot) {
1109                         vref(dvp);
1110                         *vpp = dvp;
1111                         return 0;
1112                 }
1113                 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp);
1114                 if (error)
1115                         return error;
1116                 *vpp = vp;
1117                 if (!lockparent) {
1118                         vn_unlock(dvp);
1119                         cnp->cn_flags |= CNP_PDIRUNLOCK;
1120                 }
1121                 return 0;
1122         }
1123         if (nameiop == NAMEI_RENAME && wantparent) {
1124                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
1125                 if (error)
1126                         return error;
1127                 if (isdot)
1128                         return EISDIR;
1129                 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp);
1130                 if (error)
1131                         return error;
1132                 *vpp = vp;
1133                 if (!lockparent) {
1134                         vn_unlock(dvp);
1135                         cnp->cn_flags |= CNP_PDIRUNLOCK;
1136                 }
1137                 return 0;
1138         }
1139         if (flags & CNP_ISDOTDOT) {
1140                 vn_unlock(dvp);
1141                 error = smbfs_nget(mp, dvp, name, nmlen, NULL, &vp);
1142                 if (error) {
1143                         vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
1144                         return error;
1145                 }
1146                 if (lockparent) {
1147                         error = vn_lock(dvp, LK_EXCLUSIVE);
1148                         if (error) {
1149                                 cnp->cn_flags |= CNP_PDIRUNLOCK;
1150                                 vput(vp);
1151                                 return error;
1152                         }
1153                 }
1154                 *vpp = vp;
1155         } else if (isdot) {
1156                 vref(dvp);
1157                 *vpp = dvp;
1158         } else {
1159                 error = smbfs_nget(mp, dvp, name, nmlen, fap, &vp);
1160                 if (error)
1161                         return error;
1162                 *vpp = vp;
1163                 SMBVDEBUG("lookup: getnewvp!\n");
1164                 if (!lockparent) {
1165                         vn_unlock(dvp);
1166                         cnp->cn_flags |= CNP_PDIRUNLOCK;
1167                 }
1168         }
1169         return 0;
1170 }