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