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 33 /* 34 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 35 * Use is subject to license terms. 36 * 37 * Copyright 2018 Nexenta Systems, Inc. All rights reserved. 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/inttypes.h> 43 #include <sys/time.h> 44 #include <sys/vnode.h> 45 #include <sys/sunddi.h> 46 #include <sys/cmn_err.h> 47 48 #include <netsmb/smb_osdep.h> 49 50 #include <netsmb/smb.h> 51 #include <netsmb/smb_conn.h> 52 #include <netsmb/smb_subr.h> 53 #include <netsmb/smb_rq.h> 54 55 #include <smbfs/smbfs.h> 56 #include <smbfs/smbfs_node.h> 57 #include <smbfs/smbfs_subr.h> 58 59 60 /* 61 * Todo: locking over-the-wire 62 */ 63 #if 0 // todo 64 65 int 66 smbfs_smb1_lockandx(struct smbnode *np, int op, uint32_t pid, 67 offset_t start, uint64_t len, int largelock, 68 struct smb_cred *scrp, uint32_t timeout) 69 { 70 struct smb_share *ssp = np->n_mount->smi_share; 71 struct smb_rq rq, *rqp = &rq; 72 struct mbchain *mbp; 73 uint8_t ltype = 0; 74 int error; 75 76 /* Shared lock for n_fid use below. */ 77 ASSERT(smbfs_rw_lock_held(&np->r_lkserlock, RW_READER)); 78 79 /* After reconnect, n_fid is invalid */ 80 if (np->n_vcgenid != ssp->ss_vcgenid) 81 return (ESTALE); 82 83 if (op == SMB_LOCK_SHARED) 84 ltype |= SMB_LOCKING_ANDX_SHARED_LOCK; 85 /* XXX: if (SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_LARGE_FILES)? */ 86 if (largelock) 87 ltype |= SMB_LOCKING_ANDX_LARGE_FILES; 88 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scrp); 89 if (error) 90 return (error); 91 smb_rq_getrequest(rqp, &mbp); 92 smb_rq_wstart(rqp); 93 mb_put_uint8(mbp, 0xff); /* secondary command */ 94 mb_put_uint8(mbp, 0); /* MBZ */ 95 mb_put_uint16le(mbp, 0); 96 mb_put_uint16le(mbp, np->n_fid); 97 mb_put_uint8(mbp, ltype); /* locktype */ 98 mb_put_uint8(mbp, 0); /* oplocklevel - 0 seems is NO_OPLOCK */ 99 mb_put_uint32le(mbp, timeout); /* 0 nowait, -1 infinite wait */ 100 mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 1 : 0); 101 mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 0 : 1); 102 smb_rq_wend(rqp); 103 smb_rq_bstart(rqp); 104 mb_put_uint16le(mbp, pid); 105 if (!largelock) { 106 mb_put_uint32le(mbp, start); 107 mb_put_uint32le(mbp, len); 108 } else { 109 mb_put_uint16le(mbp, 0); /* pad */ 110 mb_put_uint32le(mbp, start >> 32); /* OffsetHigh */ 111 mb_put_uint32le(mbp, start & 0xffffffff); /* OffsetLow */ 112 mb_put_uint32le(mbp, len >> 32); /* LengthHigh */ 113 mb_put_uint32le(mbp, len & 0xffffffff); /* LengthLow */ 114 } 115 smb_rq_bend(rqp); 116 /* 117 * Don't want to risk missing a successful 118 * unlock send or lock response, or we could 119 * lose track of an outstanding lock. 120 */ 121 if (op == SMB_LOCK_RELEASE) 122 rqp->sr_flags |= SMBR_NOINTR_SEND; 123 else 124 rqp->sr_flags |= SMBR_NOINTR_RECV; 125 126 error = smb_rq_simple(rqp); 127 smb_rq_done(rqp); 128 return (error); 129 } 130 131 #endif // todo 132 133 /* 134 * Common function for QueryFileInfo, QueryPathInfo. 135 */ 136 int 137 smbfs_smb1_trans2_query(struct smbnode *np, uint16_t fid, 138 struct smbfattr *fap, struct smb_cred *scrp) 139 { 140 struct smb_share *ssp = np->n_mount->smi_share; 141 struct smb_vc *vcp = SSTOVC(ssp); 142 struct smb_t2rq *t2p; 143 struct mbchain *mbp; 144 struct mdchain *mdp; 145 uint16_t cmd; 146 uint16_t infolevel = SMB_QFILEINFO_ALL_INFO; 147 int error; 148 149 /* 150 * If we have a valid open FID, use it. 151 */ 152 if (fid != SMB_FID_UNUSED) 153 cmd = SMB_TRANS2_QUERY_FILE_INFORMATION; 154 else 155 cmd = SMB_TRANS2_QUERY_PATH_INFORMATION; 156 157 error = smb_t2_alloc(SSTOCP(ssp), cmd, scrp, &t2p); 158 if (error) 159 return (error); 160 mbp = &t2p->t2_tparam; 161 mb_init(mbp); 162 163 if (cmd == SMB_TRANS2_QUERY_FILE_INFORMATION) 164 mb_put_uint16le(mbp, fid); 165 166 mb_put_uint16le(mbp, infolevel); 167 168 if (cmd == SMB_TRANS2_QUERY_PATH_INFORMATION) { 169 mb_put_uint32le(mbp, 0); 170 /* mb_put_uint8(mbp, SMB_DT_ASCII); specs are wrong */ 171 error = smbfs_fullpath(mbp, vcp, np, NULL, 0, '\\'); 172 if (error) 173 goto out; 174 } 175 176 t2p->t2_maxpcount = 2; 177 t2p->t2_maxdcount = vcp->vc_txmax; 178 error = smb_t2_request(t2p); 179 if (error) 180 goto out; 181 182 /* 183 * Parse the SMB_QFILEINFO_ALL_INFO 184 */ 185 mdp = &t2p->t2_rdata; 186 error = smbfs_decode_file_all_info(ssp, mdp, fap); 187 188 out: 189 smb_t2_done(t2p); 190 191 return (error); 192 } 193 194 /* 195 * Get some FS information 196 */ 197 static int 198 smbfs_smb1_query_fs_info(struct smb_share *ssp, struct mdchain *info_mdp, 199 uint16_t level, struct smb_cred *scrp) 200 { 201 struct smb_t2rq *t2p; 202 struct mbchain *mbp; 203 struct mdchain *mdp; 204 int error; 205 206 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION, 207 scrp, &t2p); 208 if (error) 209 return (error); 210 mbp = &t2p->t2_tparam; 211 mb_init(mbp); 212 mb_put_uint16le(mbp, level); 213 t2p->t2_maxpcount = 4; 214 t2p->t2_maxdcount = 1024; 215 error = smb_t2_request(t2p); 216 if (error) 217 goto out; 218 219 mdp = &t2p->t2_rdata; 220 *info_mdp = *mdp; 221 bzero(mdp, sizeof (*mdp)); 222 223 out: 224 smb_t2_done(t2p); 225 return (error); 226 } 227 228 /* 229 * Get FILE_FS_ATTRIBUTE_INFORMATION 230 */ 231 int 232 smbfs_smb1_qfsattr(struct smb_share *ssp, struct smb_fs_attr_info *fsa, 233 struct smb_cred *scrp) 234 { 235 struct mdchain info_mdc, *mdp = &info_mdc; 236 int error; 237 238 bzero(mdp, sizeof (*mdp)); 239 240 error = smbfs_smb1_query_fs_info(ssp, mdp, 241 SMB_QFS_ATTRIBUTE_INFO, scrp); 242 if (error) 243 goto out; 244 error = smbfs_decode_fs_attr_info(ssp, mdp, fsa); 245 246 out: 247 md_done(mdp); 248 249 return (error); 250 } 251 252 /* 253 * Get FileFsFullSizeInformation and 254 * parse into *info 255 */ 256 int 257 smbfs_smb1_statfs(struct smb_share *ssp, 258 struct smb_fs_size_info *info, 259 struct smb_cred *scrp) 260 { 261 struct mdchain info_mdc, *mdp = &info_mdc; 262 struct smb_vc *vcp = SSTOVC(ssp); 263 uint16_t level; 264 int error; 265 266 bzero(mdp, sizeof (*mdp)); 267 268 if (vcp->vc_sopt.sv_caps & SMB_CAP_INFOLEVEL_PASSTHRU) 269 level = SMB_QFS_FULL_SIZE_INFORMATION; 270 else 271 level = SMB_QFS_SIZE_INFO; 272 error = smbfs_smb1_query_fs_info(ssp, mdp, level, scrp); 273 if (error) 274 goto out; 275 276 md_get_uint64le(mdp, &info->total_units); 277 md_get_uint64le(mdp, &info->caller_avail); 278 if (level == SMB_QFS_FULL_SIZE_INFORMATION) 279 md_get_uint64le(mdp, &info->actual_avail); 280 else 281 info->actual_avail = info->caller_avail; 282 283 md_get_uint32le(mdp, &info->sect_per_unit); 284 error = md_get_uint32le(mdp, &info->bytes_per_sect); 285 286 out: 287 md_done(mdp); 288 289 return (error); 290 } 291 292 int 293 smbfs_smb1_flush(struct smb_share *ssp, uint16_t fid, struct smb_cred *scrp) 294 { 295 struct smb_rq rq, *rqp = &rq; 296 struct mbchain *mbp; 297 int error; 298 299 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_FLUSH, scrp); 300 if (error) 301 return (error); 302 smb_rq_getrequest(rqp, &mbp); 303 smb_rq_wstart(rqp); 304 mb_put_uint16le(mbp, fid); 305 smb_rq_wend(rqp); 306 smb_rq_bstart(rqp); 307 smb_rq_bend(rqp); 308 error = smb_rq_simple(rqp); 309 smb_rq_done(rqp); 310 return (error); 311 } 312 313 /* 314 * Set file info via an open handle. 315 * Caller provides payload, info level. 316 */ 317 static int 318 smbfs_smb1_setinfo_file(struct smb_share *ssp, uint16_t fid, 319 struct mbchain *info_mbp, uint16_t level, struct smb_cred *scrp) 320 { 321 struct smb_t2rq *t2p = NULL; 322 struct mbchain *mbp; 323 uint16_t cmd = SMB_TRANS2_SET_FILE_INFORMATION; 324 int error; 325 326 ASSERT(fid != SMB_FID_UNUSED); 327 328 error = smb_t2_alloc(SSTOCP(ssp), cmd, scrp, &t2p); 329 if (error) 330 return (error); 331 mbp = &t2p->t2_tparam; 332 mb_init(mbp); 333 mb_put_uint16le(mbp, fid); 334 mb_put_uint16le(mbp, level); 335 mb_put_uint16le(mbp, 0); /* pad */ 336 337 /* put the payload */ 338 mbp = &t2p->t2_tdata; 339 mb_init(mbp); 340 error = mb_put_mbchain(mbp, info_mbp); 341 if (error) 342 goto out; 343 344 t2p->t2_maxpcount = 2; 345 t2p->t2_maxdcount = 0; 346 error = smb_t2_request(t2p); 347 348 out: 349 smb_t2_done(t2p); 350 351 return (error); 352 } 353 354 int 355 smbfs_smb1_seteof(struct smb_share *ssp, uint16_t fid, 356 uint64_t newsize, struct smb_cred *scrp) 357 { 358 struct mbchain data_mb, *mbp = &data_mb; 359 uint16_t level; 360 int error; 361 362 if (SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_INFOLEVEL_PASSTHRU) 363 level = SMB_SFILEINFO_END_OF_FILE_INFORMATION; 364 else 365 level = SMB_SFILEINFO_END_OF_FILE_INFO; 366 367 mb_init(mbp); 368 error = mb_put_uint64le(mbp, newsize); 369 if (error) 370 goto out; 371 error = smbfs_smb1_setinfo_file(ssp, fid, mbp, level, scrp); 372 373 out: 374 mb_done(mbp); 375 return (error); 376 } 377 378 int 379 smbfs_smb1_setdisp(struct smb_share *ssp, uint16_t fid, 380 uint8_t newdisp, struct smb_cred *scrp) 381 { 382 struct mbchain data_mb, *mbp = &data_mb; 383 uint16_t level; 384 int error; 385 386 if (SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_INFOLEVEL_PASSTHRU) 387 level = SMB_SFILEINFO_DISPOSITION_INFORMATION; 388 else 389 level = SMB_SFILEINFO_DISPOSITION_INFO; 390 391 mb_init(mbp); 392 error = mb_put_uint8(mbp, newdisp); 393 if (error) 394 goto out; 395 error = smbfs_smb1_setinfo_file(ssp, fid, mbp, level, scrp); 396 397 out: 398 mb_done(mbp); 399 400 return (error); 401 } 402 403 /* 404 * Set FileBasicInformation on an open handle 405 * Caller builds the mbchain. 406 * Always have a FID here. 407 */ 408 int 409 smbfs_smb1_setfattr(struct smb_share *ssp, uint16_t fid, 410 struct mbchain *mbp, struct smb_cred *scrp) 411 { 412 uint16_t level; 413 int error; 414 415 if (SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_INFOLEVEL_PASSTHRU) 416 level = SMB_SFILEINFO_BASIC_INFORMATION; 417 else 418 level = SMB_SFILEINFO_BASIC_INFO; 419 error = smbfs_smb1_setinfo_file(ssp, fid, mbp, level, scrp); 420 421 return (error); 422 } 423 424 /* 425 * On SMB1, the trans2 rename only allows a rename where the 426 * source and target are in the same directory. If you give 427 * the server any separators, you get "status not supported". 428 * 429 * Why bother using this instead of smbfs_smb1_oldrename? 430 * Because it works with an open file, and some servers don't 431 * allow oldrename of a file that's currently open. We call 432 * this when deleting an open file in smbfsremove(), where 433 * the rename is always in the same directory. 434 */ 435 /*ARGSUSED*/ 436 int 437 smbfs_smb1_t2rename(struct smbnode *np, 438 const char *tname, int tnlen, 439 uint16_t fid, struct smb_cred *scrp) 440 { 441 struct smb_share *ssp = np->n_mount->smi_share; 442 struct mbchain data_mb, *mbp = &data_mb; 443 struct smb_vc *vcp = SSTOVC(ssp); 444 uint32_t *name_lenp; 445 uint16_t level = SMB_SFILEINFO_RENAME_INFORMATION; 446 int base, len; 447 int error; 448 449 mb_init(mbp); 450 mb_put_uint32le(mbp, 0); /* don't overwrite */ 451 mb_put_uint32le(mbp, 0); /* obsolete target dir fid */ 452 name_lenp = mb_reserve(mbp, 4); /* name len */ 453 454 /* New name */ 455 base = mbp->mb_count; 456 error = smb_put_dmem(mbp, vcp, tname, tnlen, SMB_CS_NONE, NULL); 457 if (error) 458 goto out; 459 len = mbp->mb_count - base; 460 *name_lenp = htolel(len); 461 462 error = smbfs_smb1_setinfo_file(ssp, fid, mbp, level, scrp); 463 464 out: 465 mb_done(mbp); 466 return (error); 467 } 468 469 /* 470 * Do an SMB1 (old style) rename using a full dest. path. 471 * This is used when renaming to a different directory, 472 * because the (preferred) t2rename can't do that. 473 */ 474 int 475 smbfs_smb1_oldrename(struct smbnode *src, struct smbnode *tdnp, 476 const char *tname, int tnmlen, struct smb_cred *scrp) 477 { 478 struct smb_rq rq, *rqp = &rq; 479 struct smb_share *ssp = src->n_mount->smi_share; 480 struct mbchain *mbp; 481 int error; 482 uint16_t fa; 483 char sep; 484 485 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_RENAME, scrp); 486 if (error) 487 return (error); 488 smb_rq_getrequest(rqp, &mbp); 489 smb_rq_wstart(rqp); 490 /* freebsd bug: Let directories be renamed - Win98 requires DIR bit */ 491 fa = (SMBTOV(src)->v_type == VDIR) ? SMB_FA_DIR : 0; 492 fa |= SMB_FA_SYSTEM | SMB_FA_HIDDEN; 493 mb_put_uint16le(mbp, fa); 494 smb_rq_wend(rqp); 495 smb_rq_bstart(rqp); 496 497 /* 498 * When we're not adding any component name, the 499 * passed sep is ignored, so just pass sep=0. 500 */ 501 mb_put_uint8(mbp, SMB_DT_ASCII); 502 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0, 0); 503 if (error) 504 goto out; 505 506 /* 507 * After XATTR directories, separator is ":" 508 */ 509 sep = (src->n_flag & N_XATTR) ? ':' : '\\'; 510 mb_put_uint8(mbp, SMB_DT_ASCII); 511 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen, sep); 512 if (error) 513 goto out; 514 515 smb_rq_bend(rqp); 516 error = smb_rq_simple(rqp); 517 out: 518 smb_rq_done(rqp); 519 return (error); 520 } 521 522 523 /* 524 * TRANS2_FIND_FIRST2/NEXT2, used for NT LM12 dialect 525 */ 526 static int 527 smbfs_smb1_trans2find2(struct smbfs_fctx *ctx) 528 { 529 struct smb_t2rq *t2p; 530 struct smb_vc *vcp = SSTOVC(ctx->f_ssp); 531 struct mbchain *mbp; 532 struct mdchain *mdp; 533 uint16_t ecnt, eos, lno, flags; 534 uint16_t amask, limit; 535 int error; 536 537 /* smbfs_smb_findnextLM2 sets this */ 538 limit = ctx->f_limit; 539 amask = (uint16_t)ctx->f_attrmask; 540 541 if (ctx->f_t2) { 542 smb_t2_done(ctx->f_t2); 543 ctx->f_t2 = NULL; 544 } 545 flags = FIND2_RETURN_RESUME_KEYS | FIND2_CLOSE_ON_EOS; 546 if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) { 547 flags |= FIND2_CLOSE_AFTER_REQUEST; 548 ctx->f_flags |= SMBFS_RDD_NOCLOSE; 549 } 550 if (ctx->f_flags & SMBFS_RDD_FINDFIRST) { 551 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_FIRST2, 552 ctx->f_scred, &t2p); 553 if (error) 554 return (error); 555 ctx->f_t2 = t2p; 556 mbp = &t2p->t2_tparam; 557 mb_init(mbp); 558 mb_put_uint16le(mbp, amask); 559 mb_put_uint16le(mbp, limit); 560 mb_put_uint16le(mbp, flags); 561 mb_put_uint16le(mbp, ctx->f_infolevel); 562 mb_put_uint32le(mbp, 0); 563 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, 564 ctx->f_wildcard, ctx->f_wclen, '\\'); 565 if (error) 566 return (error); 567 } else { 568 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_NEXT2, 569 ctx->f_scred, &t2p); 570 if (error) 571 return (error); 572 ctx->f_t2 = t2p; 573 mbp = &t2p->t2_tparam; 574 mb_init(mbp); 575 mb_put_uint16le(mbp, ctx->f_Sid); 576 mb_put_uint16le(mbp, limit); 577 mb_put_uint16le(mbp, ctx->f_infolevel); 578 /* Send whatever resume key we received... */ 579 mb_put_uint32le(mbp, ctx->f_rkey); 580 mb_put_uint16le(mbp, flags); 581 /* ... and the resume name if we have one. */ 582 if (ctx->f_rname) { 583 /* resume file name */ 584 mb_put_mem(mbp, ctx->f_rname, ctx->f_rnamelen, 585 MB_MSYSTEM); 586 } 587 /* Add trailing null - 1 byte if ASCII, 2 if Unicode */ 588 if (SMB_UNICODE_STRINGS(SSTOVC(ctx->f_ssp))) 589 mb_put_uint8(mbp, 0); /* 1st byte NULL Unicode char */ 590 mb_put_uint8(mbp, 0); 591 } 592 t2p->t2_maxpcount = 5 * 2; 593 t2p->t2_maxdcount = 0xF000; /* 64K less some overhead */ 594 error = smb_t2_request(t2p); 595 if (error) 596 return (error); 597 598 /* 599 * This is the "resume name" we just sent. 600 * We want the new one (if any) that may be 601 * found in the response we just received and 602 * will now begin parsing. Free the old one 603 * now so we'll know if we found a new one. 604 */ 605 if (ctx->f_rname) { 606 kmem_free(ctx->f_rname, ctx->f_rnamelen); 607 ctx->f_rname = NULL; 608 ctx->f_rnamelen = 0; 609 } 610 611 mdp = &t2p->t2_rparam; 612 if (ctx->f_flags & SMBFS_RDD_FINDFIRST) { 613 if ((error = md_get_uint16le(mdp, &ctx->f_Sid)) != 0) 614 goto nodata; 615 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST; 616 } 617 md_get_uint16le(mdp, &ecnt); /* entry count */ 618 md_get_uint16le(mdp, &eos); /* end of search */ 619 md_get_uint16le(mdp, NULL); /* EA err. off. */ 620 error = md_get_uint16le(mdp, &lno); /* last name off. */ 621 if (error != 0) 622 goto nodata; 623 624 /* 625 * The "end of search" flag from an XP server sometimes 626 * comes back zero when the prior find_next returned exactly 627 * the number of entries requested. in which case we'd try again 628 * but the search has in fact been closed so an EBADF results. 629 * our circumvention is to check here for a zero entry count. 630 */ 631 ctx->f_ecnt = ecnt; 632 if (eos || ctx->f_ecnt == 0) 633 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE; 634 if (ctx->f_ecnt == 0) 635 return (ENOENT); 636 637 /* Last Name Off (LNO) is the entry with the resume name. */ 638 ctx->f_rnameofs = lno; 639 ctx->f_eofs = 0; 640 641 /* 642 * Have data. Put the payload in ctx->f_mdchain 643 * Note struct assignments here. 644 */ 645 mdp = &t2p->t2_rdata; 646 md_done(&ctx->f_mdchain); 647 ctx->f_mdchain = *mdp; 648 ctx->f_left = m_fixhdr(mdp->md_top); 649 bzero(mdp, sizeof (*mdp)); 650 651 return (0); 652 653 nodata: 654 /* 655 * Failed parsing the FindFirst or FindNext response. 656 * Force this directory listing closed, otherwise the 657 * calling process may hang in an infinite loop. 658 */ 659 ctx->f_ecnt = 0; /* Force closed. */ 660 ctx->f_flags |= SMBFS_RDD_EOF; 661 return (EIO); 662 } 663 664 static int 665 smbfs_smb1_findclose2(struct smbfs_fctx *ctx) 666 { 667 struct smb_rq rq, *rqp = &rq; 668 struct mbchain *mbp; 669 int error; 670 671 error = smb_rq_init(rqp, SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, 672 ctx->f_scred); 673 if (error) 674 return (error); 675 smb_rq_getrequest(rqp, &mbp); 676 smb_rq_wstart(rqp); 677 mb_put_uint16le(mbp, ctx->f_Sid); 678 smb_rq_wend(rqp); 679 smb_rq_bstart(rqp); 680 smb_rq_bend(rqp); 681 /* Ditto comments at _smb_close */ 682 rqp->sr_flags |= SMBR_NOINTR_SEND; 683 error = smb_rq_simple(rqp); 684 smb_rq_done(rqp); 685 return (error); 686 } 687 688 /*ARGSUSED*/ 689 int 690 smbfs_smb_findopenLM2(struct smbfs_fctx *ctx, struct smbnode *dnp, 691 const char *wildcard, int wclen, uint32_t attr) 692 { 693 694 ctx->f_type = ft_LM2; 695 ctx->f_namesz = SMB_MAXFNAMELEN + 1; 696 ctx->f_name = kmem_alloc(ctx->f_namesz, KM_SLEEP); 697 ctx->f_infolevel = SMB_FIND_FULL_DIRECTORY_INFO; 698 ctx->f_attrmask = attr; 699 ctx->f_wildcard = wildcard; 700 ctx->f_wclen = wclen; 701 return (0); 702 } 703 704 int 705 smbfs_smb_findcloseLM2(struct smbfs_fctx *ctx) 706 { 707 int error = 0; 708 if (ctx->f_name) 709 kmem_free(ctx->f_name, ctx->f_namesz); 710 if (ctx->f_t2) 711 smb_t2_done(ctx->f_t2); 712 md_done(&ctx->f_mdchain); 713 714 /* 715 * If SMBFS_RDD_FINDFIRST is still set, we were opened 716 * but never saw a findfirst, so we don't have any 717 * search handle to close. 718 */ 719 if ((ctx->f_flags & (SMBFS_RDD_FINDFIRST | SMBFS_RDD_NOCLOSE)) == 0) 720 error = smbfs_smb1_findclose2(ctx); 721 return (error); 722 } 723 724 /* 725 * Get a buffer of directory entries (if we don't already have 726 * some remaining in the current buffer) then decode one. 727 */ 728 int 729 smbfs_smb_findnextLM2(struct smbfs_fctx *ctx, uint16_t limit) 730 { 731 int error; 732 733 /* 734 * If we've scanned to the end of the current buffer 735 * try to read anohther buffer of dir entries. 736 * Treat anything less than 8 bytes as an "empty" 737 * buffer to ensure we can read something. 738 * (There may be up to 8 bytes of padding.) 739 */ 740 if ((ctx->f_eofs + 8) > ctx->f_left) { 741 /* Scanned the whole buffer. */ 742 if (ctx->f_flags & SMBFS_RDD_EOF) 743 return (ENOENT); 744 ctx->f_limit = limit; 745 error = smbfs_smb1_trans2find2(ctx); 746 if (error) 747 return (error); 748 ctx->f_otws++; 749 } 750 751 /* 752 * Decode one entry, advance f_eofs 753 */ 754 error = smbfs_decode_dirent(ctx); 755 756 return (error); 757 } 758 759 /* 760 * Helper for smbfs_xa_get_streaminfo 761 * Query stream info 762 */ 763 int 764 smbfs_smb1_get_streaminfo(smbnode_t *np, struct mdchain *mdp, 765 struct smb_cred *scrp) 766 { 767 smb_share_t *ssp = np->n_mount->smi_share; 768 struct smb_vc *vcp = SSTOVC(ssp); 769 struct smb_t2rq *t2p = NULL; 770 struct mbchain *mbp; 771 mblk_t *m; 772 uint16_t cmd = SMB_TRANS2_QUERY_PATH_INFORMATION; 773 int error; 774 775 error = smb_t2_alloc(SSTOCP(ssp), cmd, scrp, &t2p); 776 if (error) 777 return (error); 778 779 mbp = &t2p->t2_tparam; 780 (void) mb_init(mbp); 781 (void) mb_put_uint16le(mbp, SMB_QFILEINFO_STREAM_INFO); 782 (void) mb_put_uint32le(mbp, 0); 783 error = smbfs_fullpath(mbp, vcp, np, NULL, 0, 0); 784 if (error) 785 goto out; 786 787 t2p->t2_maxpcount = 2; 788 t2p->t2_maxdcount = INT16_MAX; 789 error = smb_t2_request(t2p); 790 if (error) { 791 if (t2p->t2_sr_error == NT_STATUS_INVALID_PARAMETER) 792 error = ENOTSUP; 793 goto out; 794 } 795 796 /* 797 * Have data. Move it to *mdp 798 */ 799 m = t2p->t2_rdata.md_top; 800 if (m == NULL) { 801 error = EBADRPC; 802 goto out; 803 } 804 t2p->t2_rdata.md_top = NULL; 805 md_initm(mdp, m); 806 807 out: 808 smb_t2_done(t2p); 809 return (error); 810 } 811 812 /* 813 * OTW function to Get a security descriptor (SD). 814 * 815 * The *reslen param is bufsize(in) / length(out) 816 * Note: On success, this fills in mdp->md_top, 817 * which the caller should free. 818 */ 819 int 820 smbfs_smb1_getsec(struct smb_share *ssp, uint16_t fid, 821 uint32_t selector, mblk_t **res, uint32_t *reslen, 822 struct smb_cred *scrp) 823 { 824 struct smb_ntrq *ntp; 825 struct mbchain *mbp; 826 struct mdchain *mdp; 827 uint32_t dlen; 828 int error; 829 830 *res = NULL; 831 832 error = smb_nt_alloc(SSTOCP(ssp), NT_TRANSACT_QUERY_SECURITY_DESC, 833 scrp, &ntp); 834 if (error) 835 return (error); 836 837 /* Parameters part */ 838 mbp = &ntp->nt_tparam; 839 mb_init(mbp); 840 mb_put_uint16le(mbp, fid); 841 mb_put_uint16le(mbp, 0); /* reserved */ 842 mb_put_uint32le(mbp, selector); 843 /* Data part (none) */ 844 845 /* Max. returned parameters and data. */ 846 ntp->nt_maxpcount = 4; 847 ntp->nt_maxdcount = *reslen; // out buf size 848 849 error = smb_nt_request(ntp); 850 if (error && !(ntp->nt_flags & SMBT2_MOREDATA)) 851 goto done; 852 853 /* Get data len */ 854 mdp = &ntp->nt_rparam; 855 error = md_get_uint32le(mdp, &dlen); 856 if (error) 857 goto done; 858 859 /* 860 * if there's more data than we said we could receive, 861 * here is where we pick up the length of it 862 */ 863 *reslen = dlen; 864 if (dlen == 0) { 865 error = EBADRPC; 866 goto done; 867 } 868 869 /* 870 * get the SD data part. 871 */ 872 mdp = &ntp->nt_rdata; 873 error = md_get_mbuf(mdp, dlen, res); 874 875 done: 876 if (error == 0 && *res == NULL) { 877 ASSERT(*res); 878 error = EBADRPC; 879 } 880 881 smb_nt_done(ntp); 882 return (error); 883 } 884 885 886 /* 887 * OTW function to Set a security descriptor (SD). 888 * Caller data are carried in an mbchain_t. 889 * 890 * Note: This normally consumes mbp->mb_top, and clears 891 * that pointer when it does. 892 */ 893 int 894 smbfs_smb1_setsec(struct smb_share *ssp, uint16_t fid, 895 uint32_t selector, mblk_t **mp, struct smb_cred *scrp) 896 { 897 struct smb_ntrq *ntp; 898 struct mbchain *mbp; 899 int error; 900 901 error = smb_nt_alloc(SSTOCP(ssp), NT_TRANSACT_SET_SECURITY_DESC, 902 scrp, &ntp); 903 if (error) 904 return (error); 905 906 /* Parameters part */ 907 mbp = &ntp->nt_tparam; 908 mb_init(mbp); 909 mb_put_uint16le(mbp, fid); 910 mb_put_uint16le(mbp, 0); /* reserved */ 911 mb_put_uint32le(mbp, selector); 912 913 /* Data part */ 914 mbp = &ntp->nt_tdata; 915 mb_initm(mbp, *mp); 916 *mp = NULL; /* consumed */ 917 918 /* No returned parameters or data. */ 919 ntp->nt_maxpcount = 0; 920 ntp->nt_maxdcount = 0; 921 922 error = smb_nt_request(ntp); 923 smb_nt_done(ntp); 924 925 return (error); 926 } 927