sys/fs/smbfs/smbfs_smb.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  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28 #include <sys/param.h>
  29 #include <sys/systm.h>
  30 #include <sys/kernel.h>
  31 #include <sys/malloc.h>
  32 #include <sys/proc.h>
  33 #include <sys/lock.h>
  34 #include <sys/vnode.h>
  35 #include <sys/mbuf.h>
  36 #include <sys/mount.h>
  37 #include <sys/endian.h>
  38
  39 #ifdef USE_MD5_HASH
  40 #include <sys/md5.h>
  41 #endif
  42
  43 #include <netsmb/smb.h>
  44 #include <netsmb/smb_subr.h>
  45 #include <netsmb/smb_rq.h>
  46 #include <netsmb/smb_conn.h>
  47
  48 #include <fs/smbfs/smbfs.h>
  49 #include <fs/smbfs/smbfs_node.h>
  50 #include <fs/smbfs/smbfs_subr.h>
  51
  52 /*
  53  * Lack of inode numbers leads us to the problem of generating them.
  54  * Partially this problem can be solved by having a dir/file cache
  55  * with inode numbers generated from the incremented by one counter.
  56  * However this way will require too much kernel memory, gives all
  57  * sorts of locking and consistency problems, not to mentinon counter overflows.
  58  * So, I'm decided to use a hash function to generate pseudo random (and unique)
  59  * inode numbers.
  60  */
  61 static long
  62 smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
  63 {
  64 #ifdef USE_MD5_HASH
  65         MD5_CTX md5;
  66         u_int32_t state[4];
  67         long ino;
  68         int i;
  69
  70         MD5Init(&md5);
  71         MD5Update(&md5, name, nmlen);
  72         MD5Final((u_char *)state, &md5);
  73         for (i = 0, ino = 0; i < 4; i++)
  74                 ino += state[i];
  75         return dnp->n_ino + ino;
  76 #endif
  77         u_int32_t ino;
  78
  79         ino = dnp->n_ino + smbfs_hash(name, nmlen);
  80         if (ino <= 2)
  81                 ino += 3;
  82         return ino;
  83 }
  84
  85 static int
  86 smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t end,
  87         struct smb_cred *scred)
  88 {
  89         struct smb_share *ssp = np->n_mount->sm_share;
  90         struct smb_rq *rqp;
  91         struct mbchain *mbp;
  92         u_char ltype = 0;
  93         int error;
  94
  95         if (op == SMB_LOCK_SHARED)
  96                 ltype |= SMB_LOCKING_ANDX_SHARED_LOCK;
  97
  98         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scred, &rqp);
  99         if (error)
 100                 return (error);
 101         smb_rq_getrequest(rqp, &mbp);
 102         smb_rq_wstart(rqp);
 103         mb_put_uint8(mbp, 0xff);        /* secondary command */
 104         mb_put_uint8(mbp, 0);           /* MBZ */
 105         mb_put_uint16le(mbp, 0);
 106         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 107         mb_put_uint8(mbp, ltype);       /* locktype */
 108         mb_put_uint8(mbp, 0);           /* oplocklevel - 0 seems is NO_OPLOCK */
 109         mb_put_uint32le(mbp, 0);        /* timeout - break immediately */
 110         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 1 : 0);
 111         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 0 : 1);
 112         smb_rq_wend(rqp);
 113         smb_rq_bstart(rqp);
 114         mb_put_uint16le(mbp, pid);
 115         mb_put_uint32le(mbp, start);
 116         mb_put_uint32le(mbp, end - start);
 117         smb_rq_bend(rqp);
 118         error = smb_rq_simple(rqp);
 119         smb_rq_done(rqp);
 120         return error;
 121 }
 122
 123 int
 124 smbfs_smb_lock(struct smbnode *np, int op, caddr_t id,
 125         off_t start, off_t end, struct smb_cred *scred)
 126 {
 127         struct smb_share *ssp = np->n_mount->sm_share;
 128
 129         if (SMB_DIALECT(SSTOVC(ssp)) < SMB_DIALECT_LANMAN1_0)
 130                 /*
 131                  * TODO: use LOCK_BYTE_RANGE here.
 132                  */
 133                 return EINVAL;
 134         else
 135                 return smbfs_smb_lockandx(np, op, (uintptr_t)id, start, end, scred);
 136 }
 137
 138 static int
 139 smbfs_query_info_fs(struct smb_share *ssp, struct statfs *sbp,
 140         struct smb_cred *scred)
 141 {
 142         struct smb_t2rq *t2p;
 143         struct mbchain *mbp;
 144         struct mdchain *mdp;
 145         uint32_t bsize, bpu;
 146         int64_t units, funits;
 147         int error;
 148
 149         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION,
 150             scred, &t2p);
 151         if (error)
 152                 return (error);
 153         mbp = &t2p->t2_tparam;
 154         mb_init(mbp);
 155         mb_put_uint16le(mbp, SMB_QUERY_FS_SIZE_INFO);
 156         t2p->t2_maxpcount = 2;
 157         t2p->t2_maxdcount = sizeof(int64_t) * 2 + sizeof(uint32_t) * 2;
 158         error = smb_t2_request(t2p);
 159         if (error) {
 160                 smb_t2_done(t2p);
 161                 return (error);
 162         }
 163         mdp = &t2p->t2_rdata;
 164         md_get_int64le(mdp, &units);
 165         md_get_int64le(mdp, &funits);
 166         md_get_uint32le(mdp, &bpu);
 167         md_get_uint32le(mdp, &bsize);
 168         sbp->f_bsize = bpu * bsize;     /* fundamental filesystem block size */
 169         sbp->f_blocks= (uint64_t)units; /* total data blocks in filesystem */
 170         sbp->f_bfree = (uint64_t)funits;/* free blocks in fs */
 171         sbp->f_bavail= (uint64_t)funits;/* free blocks avail to non-superuser */
 172         sbp->f_files = 0xffff;          /* total file nodes in filesystem */
 173         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
 174         smb_t2_done(t2p);
 175         return (0);
 176 }
 177
 178
 179 static int
 180 smbfs_query_info_alloc(struct smb_share *ssp, struct statfs *sbp,
 181         struct smb_cred *scred)
 182 {
 183         struct smb_t2rq *t2p;
 184         struct mbchain *mbp;
 185         struct mdchain *mdp;
 186         u_int16_t bsize;
 187         u_int32_t units, bpu, funits;
 188         int error;
 189
 190         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION,
 191             scred, &t2p);
 192         if (error)
 193                 return error;
 194         mbp = &t2p->t2_tparam;
 195         mb_init(mbp);
 196         mb_put_uint16le(mbp, SMB_INFO_ALLOCATION);
 197         t2p->t2_maxpcount = 4;
 198         t2p->t2_maxdcount = 4 * 4 + 2;
 199         error = smb_t2_request(t2p);
 200         if (error) {
 201                 smb_t2_done(t2p);
 202                 return error;
 203         }
 204         mdp = &t2p->t2_rdata;
 205         md_get_uint32(mdp, NULL);       /* fs id */
 206         md_get_uint32le(mdp, &bpu);
 207         md_get_uint32le(mdp, &units);
 208         md_get_uint32le(mdp, &funits);
 209         md_get_uint16le(mdp, &bsize);
 210         sbp->f_bsize = bpu * bsize;     /* fundamental filesystem block size */
 211         sbp->f_blocks= units;           /* total data blocks in filesystem */
 212         sbp->f_bfree = funits;          /* free blocks in fs */
 213         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
 214         sbp->f_files = 0xffff;          /* total file nodes in filesystem */
 215         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
 216         smb_t2_done(t2p);
 217         return 0;
 218 }
 219
 220 static int
 221 smbfs_query_info_disk(struct smb_share *ssp, struct statfs *sbp,
 222         struct smb_cred *scred)
 223 {
 224         struct smb_rq *rqp;
 225         struct mdchain *mdp;
 226         u_int16_t units, bpu, bsize, funits;
 227         int error;
 228
 229         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK,
 230             scred, &rqp);
 231         if (error)
 232                 return (error);
 233         smb_rq_wstart(rqp);
 234         smb_rq_wend(rqp);
 235         smb_rq_bstart(rqp);
 236         smb_rq_bend(rqp);
 237         error = smb_rq_simple(rqp);
 238         if (error) {
 239                 smb_rq_done(rqp);
 240                 return error;
 241         }
 242         smb_rq_getreply(rqp, &mdp);
 243         md_get_uint16le(mdp, &units);
 244         md_get_uint16le(mdp, &bpu);
 245         md_get_uint16le(mdp, &bsize);
 246         md_get_uint16le(mdp, &funits);
 247         sbp->f_bsize = bpu * bsize;     /* fundamental filesystem block size */
 248         sbp->f_blocks= units;           /* total data blocks in filesystem */
 249         sbp->f_bfree = funits;          /* free blocks in fs */
 250         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
 251         sbp->f_files = 0xffff;          /* total file nodes in filesystem */
 252         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
 253         smb_rq_done(rqp);
 254         return 0;
 255 }
 256
 257 int
 258 smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp,
 259         struct smb_cred *scred)
 260 {
 261
 262         if (SMB_DIALECT(SSTOVC(ssp)) >= SMB_DIALECT_LANMAN2_0) {
 263                 if (smbfs_query_info_fs(ssp, sbp, scred) == 0)
 264                         return (0);
 265                 if (smbfs_query_info_alloc(ssp, sbp, scred) == 0)
 266                         return (0);
 267         }
 268         return (smbfs_query_info_disk(ssp, sbp, scred));
 269 }
 270
 271 static int
 272 smbfs_smb_seteof(struct smbnode *np, int64_t newsize, struct smb_cred *scred)
 273 {
 274         struct smb_t2rq *t2p;
 275         struct smb_share *ssp = np->n_mount->sm_share;
 276         struct mbchain *mbp;
 277         int error;
 278
 279         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
 280             scred, &t2p);
 281         if (error)
 282                 return error;
 283         mbp = &t2p->t2_tparam;
 284         mb_init(mbp);
 285         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 286         mb_put_uint16le(mbp, SMB_SET_FILE_END_OF_FILE_INFO);
 287         mb_put_uint32le(mbp, 0);
 288         mbp = &t2p->t2_tdata;
 289         mb_init(mbp);
 290         mb_put_int64le(mbp, newsize);
 291         mb_put_uint32le(mbp, 0);                        /* padding */
 292         mb_put_uint16le(mbp, 0);
 293         t2p->t2_maxpcount = 2;
 294         t2p->t2_maxdcount = 0;
 295         error = smb_t2_request(t2p);
 296         smb_t2_done(t2p);
 297         return error;
 298 }
 299
 300 static int
 301 smb_smb_flush(struct smbnode *np, struct smb_cred *scred)
 302 {
 303         struct smb_share *ssp = np->n_mount->sm_share;
 304         struct smb_rq *rqp;
 305         struct mbchain *mbp;
 306         int error;
 307
 308         if ((np->n_flag & NOPEN) == 0 || !SMBTOV(np) ||
 309             SMBTOV(np)->v_type != VREG)
 310                 return 0; /* not a regular open file */
 311         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_FLUSH, scred, &rqp);
 312         if (error)
 313                 return (error);
 314         smb_rq_getrequest(rqp, &mbp);
 315         smb_rq_wstart(rqp);
 316         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 317         smb_rq_wend(rqp);
 318         smb_rq_bstart(rqp);
 319         smb_rq_bend(rqp);
 320         error = smb_rq_simple(rqp);
 321         smb_rq_done(rqp);
 322         if (!error)
 323                 np->n_flag &= ~NFLUSHWIRE;
 324         return (error);
 325 }
 326
 327 int
 328 smbfs_smb_flush(struct smbnode *np, struct smb_cred *scred)
 329 {
 330         if (np->n_flag & NFLUSHWIRE)
 331                 return (smb_smb_flush(np, scred));
 332         return (0);
 333 }
 334
 335 int
 336 smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
 337 {
 338         struct smb_share *ssp = np->n_mount->sm_share;
 339         struct smb_rq *rqp;
 340         struct mbchain *mbp;
 341         int error;
 342
 343         if (!smbfs_smb_seteof(np, (int64_t) newsize, scred)) {
 344                 np->n_flag |= NFLUSHWIRE;
 345                 return (0);
 346         }
 347
 348         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
 349         if (error)
 350                 return (error);
 351         smb_rq_getrequest(rqp, &mbp);
 352         smb_rq_wstart(rqp);
 353         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 354         mb_put_uint16le(mbp, 0);
 355         mb_put_uint32le(mbp, newsize);
 356         mb_put_uint16le(mbp, 0);
 357         smb_rq_wend(rqp);
 358         smb_rq_bstart(rqp);
 359         mb_put_uint8(mbp, SMB_DT_DATA);
 360         mb_put_uint16le(mbp, 0);
 361         smb_rq_bend(rqp);
 362         error = smb_rq_simple(rqp);
 363         smb_rq_done(rqp);
 364         return error;
 365 }
 366
 367 int
 368 smbfs_smb_query_info(struct smbnode *np, const char *name, int len,
 369                      struct smbfattr *fap, struct smb_cred *scred)
 370 {
 371         struct smb_rq *rqp;
 372         struct smb_share *ssp = np->n_mount->sm_share;
 373         struct mbchain *mbp;
 374         struct mdchain *mdp;
 375         u_int8_t wc;
 376         int error;
 377         u_int16_t wattr;
 378         u_int32_t lint;
 379
 380         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_QUERY_INFORMATION, scred,
 381             &rqp);
 382         if (error)
 383                 return (error);
 384         smb_rq_getrequest(rqp, &mbp);
 385         smb_rq_wstart(rqp);
 386         smb_rq_wend(rqp);
 387         smb_rq_bstart(rqp);
 388         mb_put_uint8(mbp, SMB_DT_ASCII);
 389         do {
 390                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, name, len);
 391                 if (error)
 392                         break;
 393                 smb_rq_bend(rqp);
 394                 error = smb_rq_simple(rqp);
 395                 if (error)
 396                         break;
 397                 smb_rq_getreply(rqp, &mdp);
 398                 if (md_get_uint8(mdp, &wc) != 0 || wc != 10) {
 399                         error = EBADRPC;
 400                         break;
 401                 }
 402                 md_get_uint16le(mdp, &wattr);
 403                 fap->fa_attr = wattr;
 404                 /*
 405                  * Be careful using the time returned here, as
 406                  * with FAT on NT4SP6, at least, the time returned is low
 407                  * 32 bits of 100s of nanoseconds (since 1601) so it rolls
 408                  * over about every seven minutes!
 409                  */
 410                 md_get_uint32le(mdp, &lint); /* specs: secs since 1970 */
 411                 if (lint)       /* avoid bogus zero returns */
 412                         smb_time_server2local(lint, SSTOVC(ssp)->vc_sopt.sv_tz,
 413                                               &fap->fa_mtime);
 414                 md_get_uint32le(mdp, &lint);
 415                 fap->fa_size = lint;
 416         } while(0);
 417         smb_rq_done(rqp);
 418         return error;
 419 }
 420
 421 /*
 422  * Set DOS file attributes. mtime should be NULL for dialects above lm10
 423  */
 424 int
 425 smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
 426         struct smb_cred *scred)
 427 {
 428         struct smb_rq *rqp;
 429         struct smb_share *ssp = np->n_mount->sm_share;
 430         struct mbchain *mbp;
 431         u_long time;
 432         int error, svtz;
 433
 434         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred,
 435             &rqp);
 436         if (error)
 437                 return (error);
 438         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
 439         smb_rq_getrequest(rqp, &mbp);
 440         smb_rq_wstart(rqp);
 441         mb_put_uint16le(mbp, attr);
 442         if (mtime) {
 443                 smb_time_local2server(mtime, svtz, &time);
 444         } else
 445                 time = 0;
 446         mb_put_uint32le(mbp, time);             /* mtime */
 447         mb_put_mem(mbp, NULL, 5 * 2, MB_MZERO);
 448         smb_rq_wend(rqp);
 449         smb_rq_bstart(rqp);
 450         mb_put_uint8(mbp, SMB_DT_ASCII);
 451         do {
 452                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
 453                 if (error)
 454                         break;
 455                 mb_put_uint8(mbp, SMB_DT_ASCII);
 456                 if (SMB_UNICODE_STRINGS(SSTOVC(ssp))) {
 457                         mb_put_padbyte(mbp);
 458                         mb_put_uint8(mbp, 0);   /* 1st byte of NULL Unicode char */
 459                 }
 460                 mb_put_uint8(mbp, 0);
 461                 smb_rq_bend(rqp);
 462                 error = smb_rq_simple(rqp);
 463                 if (error) {
 464                         SMBERROR("smb_rq_simple(rqp) => error %d\n", error);
 465                         break;
 466                 }
 467         } while(0);
 468         smb_rq_done(rqp);
 469         return error;
 470 }
 471
 472 /*
 473  * Note, win95 doesn't support this call.
 474  */
 475 int
 476 smbfs_smb_setptime2(struct smbnode *np, struct timespec *mtime,
 477         struct timespec *atime, int attr, struct smb_cred *scred)
 478 {
 479         struct smb_t2rq *t2p;
 480         struct smb_share *ssp = np->n_mount->sm_share;
 481         struct smb_vc *vcp = SSTOVC(ssp);
 482         struct mbchain *mbp;
 483         u_int16_t date, time;
 484         int error, tzoff;
 485
 486         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
 487             scred, &t2p);
 488         if (error)
 489                 return error;
 490         mbp = &t2p->t2_tparam;
 491         mb_init(mbp);
 492         mb_put_uint16le(mbp, SMB_INFO_STANDARD);
 493         mb_put_uint32le(mbp, 0);                /* MBZ */
 494         /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
 495         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
 496         if (error) {
 497                 smb_t2_done(t2p);
 498                 return error;
 499         }
 500         tzoff = vcp->vc_sopt.sv_tz;
 501         mbp = &t2p->t2_tdata;
 502         mb_init(mbp);
 503         mb_put_uint32le(mbp, 0);                /* creation time */
 504         if (atime)
 505                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
 506         else
 507                 time = date = 0;
 508         mb_put_uint16le(mbp, date);
 509         mb_put_uint16le(mbp, time);
 510         if (mtime)
 511                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
 512         else
 513                 time = date = 0;
 514         mb_put_uint16le(mbp, date);
 515         mb_put_uint16le(mbp, time);
 516         mb_put_uint32le(mbp, 0);                /* file size */
 517         mb_put_uint32le(mbp, 0);                /* allocation unit size */
 518         mb_put_uint16le(mbp, attr);     /* DOS attr */
 519         mb_put_uint32le(mbp, 0);                /* EA size */
 520         t2p->t2_maxpcount = 5 * 2;
 521         t2p->t2_maxdcount = vcp->vc_txmax;
 522         error = smb_t2_request(t2p);
 523         smb_t2_done(t2p);
 524         return error;
 525 }
 526
 527 /*
 528  * NT level. Specially for win9x
 529  */
 530 int
 531 smbfs_smb_setpattrNT(struct smbnode *np, u_short attr, struct timespec *mtime,
 532         struct timespec *atime, struct smb_cred *scred)
 533 {
 534         struct smb_t2rq *t2p;
 535         struct smb_share *ssp = np->n_mount->sm_share;
 536         struct smb_vc *vcp = SSTOVC(ssp);
 537         struct mbchain *mbp;
 538         int64_t tm;
 539         int error, tzoff;
 540
 541         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
 542             scred, &t2p);
 543         if (error)
 544                 return error;
 545         mbp = &t2p->t2_tparam;
 546         mb_init(mbp);
 547         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
 548         mb_put_uint32le(mbp, 0);                /* MBZ */
 549         /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
 550         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
 551         if (error) {
 552                 smb_t2_done(t2p);
 553                 return error;
 554         }
 555         tzoff = vcp->vc_sopt.sv_tz;
 556         mbp = &t2p->t2_tdata;
 557         mb_init(mbp);
 558         mb_put_int64le(mbp, 0);         /* creation time */
 559         if (atime) {
 560                 smb_time_local2NT(atime, tzoff, &tm);
 561         } else
 562                 tm = 0;
 563         mb_put_int64le(mbp, tm);
 564         if (mtime) {
 565                 smb_time_local2NT(mtime, tzoff, &tm);
 566         } else
 567                 tm = 0;
 568         mb_put_int64le(mbp, tm);
 569         mb_put_int64le(mbp, tm);                /* change time */
 570         mb_put_uint32le(mbp, attr);             /* attr */
 571         t2p->t2_maxpcount = 24;
 572         t2p->t2_maxdcount = 56;
 573         error = smb_t2_request(t2p);
 574         smb_t2_done(t2p);
 575         return error;
 576 }
 577
 578 /*
 579  * Set file atime and mtime. Doesn't supported by core dialect.
 580  */
 581 int
 582 smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime,
 583         struct timespec *atime, struct smb_cred *scred)
 584 {
 585         struct smb_rq *rqp;
 586         struct smb_share *ssp = np->n_mount->sm_share;
 587         struct mbchain *mbp;
 588         u_int16_t date, time;
 589         int error, tzoff;
 590
 591         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred,
 592             &rqp);
 593         if (error)
 594                 return (error);
 595         tzoff = SSTOVC(ssp)->vc_sopt.sv_tz;
 596         smb_rq_getrequest(rqp, &mbp);
 597         smb_rq_wstart(rqp);
 598         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 599         mb_put_uint32le(mbp, 0);                /* creation time */
 600
 601         if (atime)
 602                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
 603         else
 604                 time = date = 0;
 605         mb_put_uint16le(mbp, date);
 606         mb_put_uint16le(mbp, time);
 607         if (mtime)
 608                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
 609         else
 610                 time = date = 0;
 611         mb_put_uint16le(mbp, date);
 612         mb_put_uint16le(mbp, time);
 613         smb_rq_wend(rqp);
 614         smb_rq_bstart(rqp);
 615         smb_rq_bend(rqp);
 616         error = smb_rq_simple(rqp);
 617         SMBSDEBUG("%d\n", error);
 618         smb_rq_done(rqp);
 619         return error;
 620 }
 621
 622 /*
 623  * Set DOS file attributes.
 624  * Looks like this call can be used only if SMB_CAP_NT_SMBS bit is on.
 625  */
 626 int
 627 smbfs_smb_setfattrNT(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
 628         struct timespec *atime, struct smb_cred *scred)
 629 {
 630         struct smb_t2rq *t2p;
 631         struct smb_share *ssp = np->n_mount->sm_share;
 632         struct mbchain *mbp;
 633         int64_t tm;
 634         int error, svtz;
 635
 636         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
 637             scred, &t2p);
 638         if (error)
 639                 return error;
 640         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
 641         mbp = &t2p->t2_tparam;
 642         mb_init(mbp);
 643         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
 644         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
 645         mb_put_uint32le(mbp, 0);
 646         mbp = &t2p->t2_tdata;
 647         mb_init(mbp);
 648         mb_put_int64le(mbp, 0);         /* creation time */
 649         if (atime) {
 650                 smb_time_local2NT(atime, svtz, &tm);
 651         } else
 652                 tm = 0;
 653         mb_put_int64le(mbp, tm);
 654         if (mtime) {
 655                 smb_time_local2NT(mtime, svtz, &tm);
 656         } else
 657                 tm = 0;
 658         mb_put_int64le(mbp, tm);
 659         mb_put_int64le(mbp, tm);                /* change time */
 660         mb_put_uint16le(mbp, attr);
 661         mb_put_uint32le(mbp, 0);                        /* padding */
 662         mb_put_uint16le(mbp, 0);
 663         t2p->t2_maxpcount = 2;
 664         t2p->t2_maxdcount = 0;
 665         error = smb_t2_request(t2p);
 666         smb_t2_done(t2p);
 667         return error;
 668 }
 669
 670
 671 int
 672 smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred)
 673 {
 674         struct smb_rq *rqp;
 675         struct smb_share *ssp = np->n_mount->sm_share;
 676         struct mbchain *mbp;
 677         struct mdchain *mdp;
 678         u_int8_t wc;
 679         u_int16_t fid, wattr, grantedmode;
 680         int error;
 681
 682         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_OPEN, scred, &rqp);
 683         if (error)
 684                 return (error);
 685         smb_rq_getrequest(rqp, &mbp);
 686         smb_rq_wstart(rqp);
 687         mb_put_uint16le(mbp, accmode);
 688         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
 689         smb_rq_wend(rqp);
 690         smb_rq_bstart(rqp);
 691         mb_put_uint8(mbp, SMB_DT_ASCII);
 692         do {
 693                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
 694                 if (error)
 695                         break;
 696                 smb_rq_bend(rqp);
 697                 error = smb_rq_simple(rqp);
 698                 if (error)
 699                         break;
 700                 smb_rq_getreply(rqp, &mdp);
 701                 if (md_get_uint8(mdp, &wc) != 0 || wc != 7) {
 702                         error = EBADRPC;
 703                         break;
 704                 }
 705                 md_get_uint16(mdp, &fid);
 706                 md_get_uint16le(mdp, &wattr);
 707                 md_get_uint32(mdp, NULL);       /* mtime */
 708                 md_get_uint32(mdp, NULL);       /* fsize */
 709                 md_get_uint16le(mdp, &grantedmode);
 710                 /*
 711                  * TODO: refresh attributes from this reply
 712                  */
 713         } while(0);
 714         smb_rq_done(rqp);
 715         if (error)
 716                 return error;
 717         np->n_fid = fid;
 718         np->n_rwstate = grantedmode;
 719         return 0;
 720 }
 721
 722
 723 int
 724 smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
 725         struct smb_cred *scred)
 726 {
 727         struct smb_rq *rqp;
 728         struct mbchain *mbp;
 729         u_long time;
 730         int error;
 731
 732         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CLOSE, scred, &rqp);
 733         if (error)
 734                 return (error);
 735         smb_rq_getrequest(rqp, &mbp);
 736         smb_rq_wstart(rqp);
 737         mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
 738         if (mtime) {
 739                 smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &time);
 740         } else
 741                 time = 0;
 742         mb_put_uint32le(mbp, time);
 743         smb_rq_wend(rqp);
 744         smb_rq_bstart(rqp);
 745         smb_rq_bend(rqp);
 746         error = smb_rq_simple(rqp);
 747         smb_rq_done(rqp);
 748         return error;
 749 }
 750
 751 int
 752 smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen,
 753         struct smb_cred *scred)
 754 {
 755         struct smb_rq *rqp;
 756         struct smb_share *ssp = dnp->n_mount->sm_share;
 757         struct mbchain *mbp;
 758         struct mdchain *mdp;
 759         struct timespec ctime;
 760         u_int8_t wc;
 761         u_int16_t fid;
 762         u_long tm;
 763         int error;
 764
 765         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CREATE, scred, &rqp);
 766         if (error)
 767                 return (error);
 768         smb_rq_getrequest(rqp, &mbp);
 769         smb_rq_wstart(rqp);
 770         mb_put_uint16le(mbp, SMB_FA_ARCHIVE);           /* attributes  */
 771         nanotime(&ctime);
 772         smb_time_local2server(&ctime, SSTOVC(ssp)->vc_sopt.sv_tz, &tm);
 773         mb_put_uint32le(mbp, tm);
 774         smb_rq_wend(rqp);
 775         smb_rq_bstart(rqp);
 776         mb_put_uint8(mbp, SMB_DT_ASCII);
 777         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, nmlen);
 778         if (!error) {
 779                 smb_rq_bend(rqp);
 780                 error = smb_rq_simple(rqp);
 781                 if (!error) {
 782                         smb_rq_getreply(rqp, &mdp);
 783                         md_get_uint8(mdp, &wc);
 784                         if (wc == 1)
 785                                 md_get_uint16(mdp, &fid);
 786                         else
 787                                 error = EBADRPC;
 788                 }
 789         }
 790         smb_rq_done(rqp);
 791         if (error)
 792                 return error;
 793         smbfs_smb_close(ssp, fid, &ctime, scred);
 794         return error;
 795 }
 796
 797 int
 798 smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred)
 799 {
 800         struct smb_rq *rqp;
 801         struct smb_share *ssp = np->n_mount->sm_share;
 802         struct mbchain *mbp;
 803         int error;
 804
 805         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_DELETE, scred, &rqp);
 806         if (error)
 807                 return (error);
 808         smb_rq_getrequest(rqp, &mbp);
 809         smb_rq_wstart(rqp);
 810         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
 811         smb_rq_wend(rqp);
 812         smb_rq_bstart(rqp);
 813         mb_put_uint8(mbp, SMB_DT_ASCII);
 814         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
 815         if (!error) {
 816                 smb_rq_bend(rqp);
 817                 error = smb_rq_simple(rqp);
 818         }
 819         smb_rq_done(rqp);
 820         return error;
 821 }
 822
 823 int
 824 smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp,
 825         const char *tname, int tnmlen, struct smb_cred *scred)
 826 {
 827         struct smb_rq *rqp;
 828         struct smb_share *ssp = src->n_mount->sm_share;
 829         struct mbchain *mbp;
 830         int error;
 831
 832         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_RENAME, scred, &rqp);
 833         if (error)
 834                 return (error);
 835         smb_rq_getrequest(rqp, &mbp);
 836         smb_rq_wstart(rqp);
 837         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
 838         smb_rq_wend(rqp);
 839         smb_rq_bstart(rqp);
 840         mb_put_uint8(mbp, SMB_DT_ASCII);
 841         do {
 842                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
 843                 if (error)
 844                         break;
 845                 mb_put_uint8(mbp, SMB_DT_ASCII);
 846                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
 847                 if (error)
 848                         break;
 849                 smb_rq_bend(rqp);
 850                 error = smb_rq_simple(rqp);
 851         } while(0);
 852         smb_rq_done(rqp);
 853         return error;
 854 }
 855
 856 int
 857 smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp,
 858         const char *tname, int tnmlen, u_int16_t flags, struct smb_cred *scred)
 859 {
 860         struct smb_rq *rqp;
 861         struct smb_share *ssp = src->n_mount->sm_share;
 862         struct mbchain *mbp;
 863         int error;
 864
 865         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_MOVE, scred, &rqp);
 866         if (error)
 867                 return (error);
 868         smb_rq_getrequest(rqp, &mbp);
 869         smb_rq_wstart(rqp);
 870         mb_put_uint16le(mbp, SMB_TID_UNKNOWN);
 871         mb_put_uint16le(mbp, 0x20);     /* delete target file */
 872         mb_put_uint16le(mbp, flags);
 873         smb_rq_wend(rqp);
 874         smb_rq_bstart(rqp);
 875         mb_put_uint8(mbp, SMB_DT_ASCII);
 876         do {
 877                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
 878                 if (error)
 879                         break;
 880                 mb_put_uint8(mbp, SMB_DT_ASCII);
 881                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
 882                 if (error)
 883                         break;
 884                 smb_rq_bend(rqp);
 885                 error = smb_rq_simple(rqp);
 886         } while(0);
 887         smb_rq_done(rqp);
 888         return error;
 889 }
 890
 891 int
 892 smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len,
 893         struct smb_cred *scred)
 894 {
 895         struct smb_rq *rqp;
 896         struct smb_share *ssp = dnp->n_mount->sm_share;
 897         struct mbchain *mbp;
 898         int error;
 899
 900         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred,
 901             &rqp);
 902         if (error)
 903                 return (error);
 904         smb_rq_getrequest(rqp, &mbp);
 905         smb_rq_wstart(rqp);
 906         smb_rq_wend(rqp);
 907         smb_rq_bstart(rqp);
 908         mb_put_uint8(mbp, SMB_DT_ASCII);
 909         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, len);
 910         if (!error) {
 911                 smb_rq_bend(rqp);
 912                 error = smb_rq_simple(rqp);
 913         }
 914         smb_rq_done(rqp);
 915         return error;
 916 }
 917
 918 int
 919 smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred)
 920 {
 921         struct smb_rq *rqp;
 922         struct smb_share *ssp = np->n_mount->sm_share;
 923         struct mbchain *mbp;
 924         int error;
 925
 926         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred,
 927             &rqp);
 928         if (error)
 929                 return (error);
 930         smb_rq_getrequest(rqp, &mbp);
 931         smb_rq_wstart(rqp);
 932         smb_rq_wend(rqp);
 933         smb_rq_bstart(rqp);
 934         mb_put_uint8(mbp, SMB_DT_ASCII);
 935         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
 936         if (!error) {
 937                 smb_rq_bend(rqp);
 938                 error = smb_rq_simple(rqp);
 939         }
 940         smb_rq_done(rqp);
 941         return error;
 942 }
 943
 944 static int
 945 smbfs_smb_search(struct smbfs_fctx *ctx)
 946 {
 947         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
 948         struct smb_rq *rqp;
 949         struct mbchain *mbp;
 950         struct mdchain *mdp;
 951         u_int8_t wc, bt;
 952         u_int16_t ec, dlen, bc;
 953         int maxent, error, iseof = 0;
 954
 955         maxent = min(ctx->f_left, (vcp->vc_txmax - SMB_HDRLEN - 3) / SMB_DENTRYLEN);
 956         if (ctx->f_rq) {
 957                 smb_rq_done(ctx->f_rq);
 958                 ctx->f_rq = NULL;
 959         }
 960         error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_SEARCH, ctx->f_scred, &rqp);
 961         if (error)
 962                 return (error);
 963         ctx->f_rq = rqp;
 964         smb_rq_getrequest(rqp, &mbp);
 965         smb_rq_wstart(rqp);
 966         mb_put_uint16le(mbp, maxent);   /* max entries to return */
 967         mb_put_uint16le(mbp, ctx->f_attrmask);
 968         smb_rq_wend(rqp);
 969         smb_rq_bstart(rqp);
 970         mb_put_uint8(mbp, SMB_DT_ASCII);        /* buffer format */
 971         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
 972                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
 973                 if (error)
 974                         return error;
 975                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
 976                 mb_put_uint16le(mbp, 0);        /* context length */
 977                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
 978         } else {
 979                 if (SMB_UNICODE_STRINGS(vcp)) {
 980                         mb_put_padbyte(mbp);
 981                         mb_put_uint8(mbp, 0);
 982                 }
 983                 mb_put_uint8(mbp, 0);   /* file name length */
 984                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
 985                 mb_put_uint16le(mbp, SMB_SKEYLEN);
 986                 mb_put_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
 987         }
 988         smb_rq_bend(rqp);
 989         error = smb_rq_simple(rqp);
 990         if (error) {
 991                 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnofiles) {
 992                         error = 0;
 993                         iseof = 1;
 994                         ctx->f_flags |= SMBFS_RDD_EOF;
 995                 } else
 996                         return error;
 997         }
 998         smb_rq_getreply(rqp, &mdp);
 999         md_get_uint8(mdp, &wc);
1000         if (wc != 1)
1001                 return iseof ? ENOENT : EBADRPC;
1002         md_get_uint16le(mdp, &ec);
1003         if (ec == 0)
1004                 return ENOENT;
1005         ctx->f_ecnt = ec;
1006         md_get_uint16le(mdp, &bc);
1007         if (bc < 3)
1008                 return EBADRPC;
1009         bc -= 3;
1010         md_get_uint8(mdp, &bt);
1011         if (bt != SMB_DT_VARIABLE)
1012                 return EBADRPC;
1013         md_get_uint16le(mdp, &dlen);
1014         if (dlen != bc || dlen % SMB_DENTRYLEN != 0)
1015                 return EBADRPC;
1016         return 0;
1017 }
1018
1019 static int
1020 smbfs_findopenLM1(struct smbfs_fctx *ctx, struct smbnode *dnp,
1021         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
1022 {
1023         ctx->f_attrmask = attr;
1024         if (wildcard) {
1025                 if (wclen == 1 && wildcard[0] == '*') {
1026                         ctx->f_wildcard = "*.*";
1027                         ctx->f_wclen = 3;
1028                 } else {
1029                         ctx->f_wildcard = wildcard;
1030                         ctx->f_wclen = wclen;
1031                 }
1032         } else {
1033                 ctx->f_wildcard = NULL;
1034                 ctx->f_wclen = 0;
1035         }
1036         ctx->f_name = ctx->f_fname;
1037         return 0;
1038 }
1039
1040 static int
1041 smbfs_findnextLM1(struct smbfs_fctx *ctx, int limit)
1042 {
1043         struct mdchain *mbp;
1044         struct smb_rq *rqp;
1045         char *cp;
1046         u_int8_t battr;
1047         u_int16_t date, time;
1048         u_int32_t size;
1049         int error;
1050
1051         if (ctx->f_ecnt == 0) {
1052                 if (ctx->f_flags & SMBFS_RDD_EOF)
1053                         return ENOENT;
1054                 ctx->f_left = ctx->f_limit = limit;
1055                 error = smbfs_smb_search(ctx);
1056                 if (error)
1057                         return error;
1058         }
1059         rqp = ctx->f_rq;
1060         smb_rq_getreply(rqp, &mbp);
1061         md_get_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
1062         md_get_uint8(mbp, &battr);
1063         md_get_uint16le(mbp, &time);
1064         md_get_uint16le(mbp, &date);
1065         md_get_uint32le(mbp, &size);
1066         cp = ctx->f_name;
1067         md_get_mem(mbp, cp, sizeof(ctx->f_fname), MB_MSYSTEM);
1068         cp[sizeof(ctx->f_fname) - 1] = 0;
1069         cp += strlen(cp) - 1;
1070         while (*cp == ' ' && cp >= ctx->f_name)
1071                 *cp-- = 0;
1072         ctx->f_attr.fa_attr = battr;
1073         smb_dos2unixtime(date, time, 0, rqp->sr_vc->vc_sopt.sv_tz,
1074             &ctx->f_attr.fa_mtime);
1075         ctx->f_attr.fa_size = size;
1076         ctx->f_nmlen = strlen(ctx->f_name);
1077         ctx->f_ecnt--;
1078         ctx->f_left--;
1079         return 0;
1080 }
1081
1082 static int
1083 smbfs_findcloseLM1(struct smbfs_fctx *ctx)
1084 {
1085         if (ctx->f_rq)
1086                 smb_rq_done(ctx->f_rq);
1087         return 0;
1088 }
1089
1090 /*
1091  * TRANS2_FIND_FIRST2/NEXT2, used for NT LM12 dialect
1092  */
1093 static int
1094 smbfs_smb_trans2find2(struct smbfs_fctx *ctx)
1095 {
1096         struct smb_t2rq *t2p;
1097         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
1098         struct mbchain *mbp;
1099         struct mdchain *mdp;
1100         u_int16_t tw, flags;
1101         int error;
1102
1103         if (ctx->f_t2) {
1104                 smb_t2_done(ctx->f_t2);
1105                 ctx->f_t2 = NULL;
1106         }
1107         ctx->f_flags &= ~SMBFS_RDD_GOTRNAME;
1108         flags = 8 | 2;                  /* <resume> | <close if EOS> */
1109         if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
1110                 flags |= 1;             /* close search after this request */
1111                 ctx->f_flags |= SMBFS_RDD_NOCLOSE;
1112         }
1113         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
1114                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_FIRST2,
1115                     ctx->f_scred, &t2p);
1116                 if (error)
1117                         return error;
1118                 ctx->f_t2 = t2p;
1119                 mbp = &t2p->t2_tparam;
1120                 mb_init(mbp);
1121                 mb_put_uint16le(mbp, ctx->f_attrmask);
1122                 mb_put_uint16le(mbp, ctx->f_limit);
1123                 mb_put_uint16le(mbp, flags);
1124                 mb_put_uint16le(mbp, ctx->f_infolevel);
1125                 mb_put_uint32le(mbp, 0);
1126                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
1127                 if (error)
1128                         return error;
1129         } else  {
1130                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_NEXT2,
1131                     ctx->f_scred, &t2p);
1132                 if (error)
1133                         return error;
1134                 ctx->f_t2 = t2p;
1135                 mbp = &t2p->t2_tparam;
1136                 mb_init(mbp);
1137                 mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
1138                 mb_put_uint16le(mbp, ctx->f_limit);
1139                 mb_put_uint16le(mbp, ctx->f_infolevel);
1140                 mb_put_uint32le(mbp, 0);                /* resume key */
1141                 mb_put_uint16le(mbp, flags);
1142                 if (ctx->f_rname)
1143                         mb_put_mem(mbp, ctx->f_rname, ctx->f_rnamelen + 1, MB_MSYSTEM);
1144                 else
1145                         mb_put_uint8(mbp, 0);   /* resume file name */
1146 #if 0
1147         struct timeval tv;
1148         tv.tv_sec = 0;
1149         tv.tv_usec = 200 * 1000;        /* 200ms */
1150                 if (vcp->vc_flags & SMBC_WIN95) {
1151                         /*
1152                          * some implementations suggests to sleep here
1153                          * for 200ms, due to the bug in the Win95.
1154                          * I've didn't notice any problem, but put code
1155                          * for it.
1156                          */
1157                          pause("fix95", tvtohz(&tv));
1158                 }
1159 #endif
1160         }
1161         t2p->t2_maxpcount = 5 * 2;
1162         t2p->t2_maxdcount = vcp->vc_txmax;
1163         error = smb_t2_request(t2p);
1164         if (error)
1165                 return error;
1166         mdp = &t2p->t2_rparam;
1167         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
1168                 if ((error = md_get_uint16(mdp, &ctx->f_Sid)) != 0)
1169                         return error;
1170                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
1171         }
1172         if ((error = md_get_uint16le(mdp, &tw)) != 0)
1173                 return error;
1174         ctx->f_ecnt = tw;
1175         if ((error = md_get_uint16le(mdp, &tw)) != 0)
1176                 return error;
1177         if (tw)
1178                 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
1179         if ((error = md_get_uint16le(mdp, &tw)) != 0)
1180                 return error;
1181         if ((error = md_get_uint16le(mdp, &tw)) != 0)
1182                 return error;
1183         if (ctx->f_ecnt == 0) {
1184                 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
1185                 return ENOENT;
1186         }
1187         ctx->f_rnameofs = tw;
1188         mdp = &t2p->t2_rdata;
1189         if (mdp->md_top == NULL) {
1190                 printf("bug: ecnt = %d, but data is NULL (please report)\n", ctx->f_ecnt);
1191                 return ENOENT;
1192         }
1193         if (mdp->md_top->m_len == 0) {
1194                 printf("bug: ecnt = %d, but m_len = 0 and m_next = %p (please report)\n", ctx->f_ecnt,mbp->mb_top->m_next);
1195                 return ENOENT;
1196         }
1197         ctx->f_eofs = 0;
1198         return 0;
1199 }
1200
1201 static int
1202 smbfs_smb_findclose2(struct smbfs_fctx *ctx)
1203 {
1204         struct smb_rq *rqp;
1205         struct mbchain *mbp;
1206         int error;
1207
1208         error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2,
1209             ctx->f_scred, &rqp);
1210         if (error)
1211                 return (error);
1212         smb_rq_getrequest(rqp, &mbp);
1213         smb_rq_wstart(rqp);
1214         mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
1215         smb_rq_wend(rqp);
1216         smb_rq_bstart(rqp);
1217         smb_rq_bend(rqp);
1218         error = smb_rq_simple(rqp);
1219         smb_rq_done(rqp);
1220         return error;
1221 }
1222
1223 static int
1224 smbfs_findopenLM2(struct smbfs_fctx *ctx, struct smbnode *dnp,
1225         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
1226 {
1227         if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) {
1228                 ctx->f_name = malloc(SMB_MAXFNAMELEN * 2, M_SMBFSDATA, M_WAITOK);
1229         } else
1230                 ctx->f_name = malloc(SMB_MAXFNAMELEN, M_SMBFSDATA, M_WAITOK);
1231         ctx->f_infolevel = SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_NTLM0_12 ?
1232             SMB_INFO_STANDARD : SMB_FIND_FILE_DIRECTORY_INFO;
1233         ctx->f_attrmask = attr;
1234         ctx->f_wildcard = wildcard;
1235         ctx->f_wclen = wclen;
1236         return 0;
1237 }
1238
1239 static int
1240 smbfs_findnextLM2(struct smbfs_fctx *ctx, int limit)
1241 {
1242         struct mdchain *mbp;
1243         struct smb_t2rq *t2p;
1244         char *cp;
1245         u_int8_t tb;
1246         u_int16_t date, time, wattr;
1247         u_int32_t size, next, dattr;
1248         int64_t lint;
1249         int error, svtz, cnt, fxsz, nmlen, recsz;
1250
1251         if (ctx->f_ecnt == 0) {
1252                 if (ctx->f_flags & SMBFS_RDD_EOF)
1253                         return ENOENT;
1254                 ctx->f_left = ctx->f_limit = limit;
1255                 error = smbfs_smb_trans2find2(ctx);
1256                 if (error)
1257                         return error;
1258         }
1259         t2p = ctx->f_t2;
1260         mbp = &t2p->t2_rdata;
1261         svtz = SSTOVC(ctx->f_ssp)->vc_sopt.sv_tz;
1262         switch (ctx->f_infolevel) {
1263             case SMB_INFO_STANDARD:
1264                 next = 0;
1265                 fxsz = 0;
1266                 md_get_uint16le(mbp, &date);
1267                 md_get_uint16le(mbp, &time);    /* creation time */
1268                 md_get_uint16le(mbp, &date);
1269                 md_get_uint16le(mbp, &time);    /* access time */
1270                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_atime);
1271                 md_get_uint16le(mbp, &date);
1272                 md_get_uint16le(mbp, &time);    /* access time */
1273                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_mtime);
1274                 md_get_uint32le(mbp, &size);
1275                 ctx->f_attr.fa_size = size;
1276                 md_get_uint32(mbp, NULL);       /* allocation size */
1277                 md_get_uint16le(mbp, &wattr);
1278                 ctx->f_attr.fa_attr = wattr;
1279                 md_get_uint8(mbp, &tb);
1280                 size = nmlen = tb;
1281                 fxsz = 23;
1282                 recsz = next = 24 + nmlen;      /* docs misses zero byte at end */
1283                 break;
1284             case SMB_FIND_FILE_DIRECTORY_INFO:
1285                 md_get_uint32le(mbp, &next);
1286                 md_get_uint32(mbp, NULL);       /* file index */
1287                 md_get_int64(mbp, NULL);        /* creation time */
1288                 md_get_int64le(mbp, &lint);
1289                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_atime);
1290                 md_get_int64le(mbp, &lint);
1291                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_mtime);
1292                 md_get_int64le(mbp, &lint);
1293                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_ctime);
1294                 md_get_int64le(mbp, &lint);     /* file size */
1295                 ctx->f_attr.fa_size = lint;
1296                 md_get_int64(mbp, NULL);        /* real size (should use) */
1297                 md_get_uint32le(mbp, &dattr);   /* EA */
1298                 ctx->f_attr.fa_attr = dattr;
1299                 md_get_uint32le(mbp, &size);    /* name len */
1300                 fxsz = 64;
1301                 recsz = next ? next : fxsz + size;
1302                 break;
1303             default:
1304                 SMBERROR("unexpected info level %d\n", ctx->f_infolevel);
1305                 return EINVAL;
1306         }
1307         if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) {
1308                 nmlen = min(size, SMB_MAXFNAMELEN * 2);
1309         } else
1310                 nmlen = min(size, SMB_MAXFNAMELEN);
1311         cp = ctx->f_name;
1312         error = md_get_mem(mbp, cp, nmlen, MB_MSYSTEM);
1313         if (error)
1314                 return error;
1315         if (next) {
1316                 cnt = next - nmlen - fxsz;
1317                 if (cnt > 0)
1318                         md_get_mem(mbp, NULL, cnt, MB_MSYSTEM);
1319                 else if (cnt < 0) {
1320                         SMBERROR("out of sync\n");
1321                         return EBADRPC;
1322                 }
1323         }
1324         if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) {
1325                 if (nmlen > 1 && cp[nmlen - 1] == 0 && cp[nmlen - 2] == 0)
1326                         nmlen -= 2;
1327         } else
1328                 if (nmlen && cp[nmlen - 1] == 0)
1329                         nmlen--;
1330         if (nmlen == 0)
1331                 return EBADRPC;
1332
1333         next = ctx->f_eofs + recsz;
1334         if (ctx->f_rnameofs && (ctx->f_flags & SMBFS_RDD_GOTRNAME) == 0 &&
1335             (ctx->f_rnameofs >= ctx->f_eofs && ctx->f_rnameofs < next)) {
1336                 /*
1337                  * Server needs a resume filename.
1338                  */
1339                 if (ctx->f_rnamelen <= nmlen) {
1340                         if (ctx->f_rname)
1341                                 free(ctx->f_rname, M_SMBFSDATA);
1342                         ctx->f_rname = malloc(nmlen + 1, M_SMBFSDATA, M_WAITOK);
1343                         ctx->f_rnamelen = nmlen;
1344                 }
1345                 bcopy(ctx->f_name, ctx->f_rname, nmlen);
1346                 ctx->f_rname[nmlen] = 0;
1347                 ctx->f_flags |= SMBFS_RDD_GOTRNAME;
1348         }
1349         ctx->f_nmlen = nmlen;
1350         ctx->f_eofs = next;
1351         ctx->f_ecnt--;
1352         ctx->f_left--;
1353         return 0;
1354 }
1355
1356 static int
1357 smbfs_findcloseLM2(struct smbfs_fctx *ctx)
1358 {
1359         if (ctx->f_name)
1360                 free(ctx->f_name, M_SMBFSDATA);
1361         if (ctx->f_t2)
1362                 smb_t2_done(ctx->f_t2);
1363         if ((ctx->f_flags & SMBFS_RDD_NOCLOSE) == 0)
1364                 smbfs_smb_findclose2(ctx);
1365         return 0;
1366 }
1367
1368 int
1369 smbfs_findopen(struct smbnode *dnp, const char *wildcard, int wclen, int attr,
1370         struct smb_cred *scred, struct smbfs_fctx **ctxpp)
1371 {
1372         struct smbfs_fctx *ctx;
1373         int error;
1374
1375         ctx = malloc(sizeof(*ctx), M_SMBFSDATA, M_WAITOK | M_ZERO);
1376         ctx->f_ssp = dnp->n_mount->sm_share;
1377         ctx->f_dnp = dnp;
1378         ctx->f_flags = SMBFS_RDD_FINDFIRST;
1379         ctx->f_scred = scred;
1380         if (SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_LANMAN2_0 ||
1381             (dnp->n_mount->sm_flags & SMBFS_MOUNT_NO_LONG)) {
1382                 ctx->f_flags |= SMBFS_RDD_USESEARCH;
1383                 error = smbfs_findopenLM1(ctx, dnp, wildcard, wclen, attr, scred);
1384         } else
1385                 error = smbfs_findopenLM2(ctx, dnp, wildcard, wclen, attr, scred);
1386         if (error)
1387                 smbfs_findclose(ctx, scred);
1388         else
1389                 *ctxpp = ctx;
1390         return error;
1391 }
1392
1393 int
1394 smbfs_findnext(struct smbfs_fctx *ctx, int limit, struct smb_cred *scred)
1395 {
1396         int error;
1397
1398         if (limit == 0)
1399                 limit = 1000000;
1400         else if (limit > 1)
1401                 limit *= 4;     /* imperical */
1402         ctx->f_scred = scred;
1403         for (;;) {
1404                 if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1405                         error = smbfs_findnextLM1(ctx, limit);
1406                 } else
1407                         error = smbfs_findnextLM2(ctx, limit);
1408                 if (error)
1409                         return error;
1410                 if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) {
1411                         if ((ctx->f_nmlen == 2 &&
1412                              *(u_int16_t *)ctx->f_name == htole16(0x002e)) ||
1413                             (ctx->f_nmlen == 4 &&
1414                              *(u_int32_t *)ctx->f_name == htole32(0x002e002e)))
1415                                 continue;
1416                 } else
1417                         if ((ctx->f_nmlen == 1 && ctx->f_name[0] == '.') ||
1418                             (ctx->f_nmlen == 2 && ctx->f_name[0] == '.' &&
1419                              ctx->f_name[1] == '.'))
1420                                 continue;
1421                 break;
1422         }
1423         smbfs_fname_tolocal(SSTOVC(ctx->f_ssp), ctx->f_name, &ctx->f_nmlen,
1424                             ctx->f_dnp->n_mount->sm_caseopt);
1425         ctx->f_attr.fa_ino = smbfs_getino(ctx->f_dnp, ctx->f_name, ctx->f_nmlen);
1426         return 0;
1427 }
1428
1429 int
1430 smbfs_findclose(struct smbfs_fctx *ctx, struct smb_cred *scred)
1431 {
1432         ctx->f_scred = scred;
1433         if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1434                 smbfs_findcloseLM1(ctx);
1435         } else
1436                 smbfs_findcloseLM2(ctx);
1437         if (ctx->f_rname)
1438                 free(ctx->f_rname, M_SMBFSDATA);
1439         free(ctx, M_SMBFSDATA);
1440         return 0;
1441 }
1442
1443 int
1444 smbfs_smb_lookup(struct smbnode *dnp, const char *name, int nmlen,
1445         struct smbfattr *fap, struct smb_cred *scred)
1446 {
1447         struct smbfs_fctx *ctx;
1448         int error;
1449
1450         if (dnp == NULL || (dnp->n_ino == 2 && name == NULL)) {
1451                 bzero(fap, sizeof(*fap));
1452                 fap->fa_attr = SMB_FA_DIR;
1453                 fap->fa_ino = 2;
1454                 return 0;
1455         }
1456         MPASS(!(nmlen == 2 && name[0] == '.' && name[1] == '.'));
1457         MPASS(!(nmlen == 1 && name[0] == '.'));
1458         ASSERT_VOP_ELOCKED(dnp->n_vnode, "smbfs_smb_lookup");
1459         error = smbfs_findopen(dnp, name, nmlen,
1460             SMB_FA_SYSTEM | SMB_FA_HIDDEN | SMB_FA_DIR, scred, &ctx);
1461         if (error)
1462                 return error;
1463         ctx->f_flags |= SMBFS_RDD_FINDSINGLE;
1464         error = smbfs_findnext(ctx, 1, scred);
1465         if (error == 0) {
1466                 *fap = ctx->f_attr;
1467                 if (name == NULL)
1468                         fap->fa_ino = dnp->n_ino;
1469         }
1470         smbfs_findclose(ctx, scred);
1471         return error;
1472 }