1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <sys/synch.h> 27 #include <smbsrv/smb_kproto.h> 28 #include <smbsrv/smb_fsops.h> 29 #include <sys/nbmlock.h> 30 31 /* 32 * SMB_TRANS2_SET_FILE/PATH_INFO (RENAME_INFORMATION level) flag 33 */ 34 #define SMB_RENAME_FLAG_OVERWRITE 0x001 35 36 static int smb_rename_check_stream(smb_fqi_t *, smb_fqi_t *); 37 static int smb_rename_check_attr(smb_request_t *, smb_node_t *, uint16_t); 38 static int smb_rename_lookup_src(smb_request_t *); 39 static void smb_rename_release_src(smb_request_t *); 40 static uint32_t smb_rename_errno2status(int); 41 42 /* 43 * smb_setinfo_rename 44 * 45 * Implements SMB_FILE_RENAME_INFORMATION level of Trans2_Set_FileInfo 46 * and Trans2_Set_PathInfo and SMB2 set_info, FileRenameInformation. 47 * If the new filename (dst_fqi) already exists it may be overwritten 48 * if flags == 1. 49 * 50 * The passed path is a full path relative to the share root. 51 * 52 * Returns NT status codes. 53 * 54 * Similar to smb_setinfo_link(), below. 55 */ 56 uint32_t 57 smb_setinfo_rename(smb_request_t *sr, smb_node_t *node, char *path, int flags) 58 { 59 smb_fqi_t *src_fqi = &sr->arg.dirop.fqi; 60 smb_fqi_t *dst_fqi = &sr->arg.dirop.dst_fqi; 61 smb_pathname_t *dst_pn = &dst_fqi->fq_path; 62 uint32_t status; 63 64 sr->arg.dirop.flags = flags ? SMB_RENAME_FLAG_OVERWRITE : 0; 65 sr->arg.dirop.info_level = FileRenameInformation; 66 67 src_fqi->fq_sattr = SMB_SEARCH_ATTRIBUTES; 68 src_fqi->fq_fnode = node; 69 src_fqi->fq_dnode = node->n_dnode; 70 71 /* validate the dst pathname */ 72 smb_pathname_init(sr, dst_pn, path); 73 if (!smb_pathname_validate(sr, dst_pn)) 74 return (NT_STATUS_OBJECT_NAME_INVALID); 75 76 status = smb_common_rename(sr, src_fqi, dst_fqi); 77 return (status); 78 } 79 80 /* 81 * smb_common_rename 82 * 83 * Common code for renaming a file. 84 * 85 * If the source and destination are identical, we go through all 86 * the checks but we don't actually do the rename. If the source 87 * and destination files differ only in case, we do a case-sensitive 88 * rename. Otherwise, we do a full case-insensitive rename. 89 * 90 * Returns NT status values. 91 * 92 * Similar to smb_make_link(), below. 93 */ 94 uint32_t 95 smb_common_rename(smb_request_t *sr, smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi) 96 { 97 smb_node_t *src_fnode, *src_dnode, *dst_dnode; 98 smb_node_t *dst_fnode = 0; 99 smb_node_t *tnode; 100 char *new_name, *path; 101 DWORD status; 102 int rc, count; 103 104 tnode = sr->tid_tree->t_snode; 105 path = dst_fqi->fq_path.pn_path; 106 107 /* Check if attempting to rename a stream - not yet supported */ 108 rc = smb_rename_check_stream(src_fqi, dst_fqi); 109 if (rc != 0) 110 return (smb_rename_errno2status(rc)); 111 112 /* 113 * The source node may already have been provided, 114 * i.e. when called by SMB1/SMB2 smb_setinfo_rename. 115 * Not provided by smb_com_rename, smb_com_nt_rename. 116 */ 117 if (src_fqi->fq_fnode) { 118 smb_node_start_crit(src_fqi->fq_fnode, RW_READER); 119 smb_node_ref(src_fqi->fq_fnode); 120 smb_node_ref(src_fqi->fq_dnode); 121 } else { 122 /* lookup and validate src node */ 123 rc = smb_rename_lookup_src(sr); 124 if (rc != 0) 125 return (smb_rename_errno2status(rc)); 126 } 127 128 src_fnode = src_fqi->fq_fnode; 129 src_dnode = src_fqi->fq_dnode; 130 131 /* 132 * Find the destination dnode and last component. 133 * May already be provided, i.e. when called via 134 * SMB1 trans2 setinfo. 135 */ 136 if (dst_fqi->fq_dnode) { 137 /* called via smb_set_rename_info */ 138 smb_node_ref(dst_fqi->fq_dnode); 139 } else { 140 /* called via smb2_setf_rename, smb_com_rename, etc. */ 141 rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode, 142 &dst_fqi->fq_dnode, dst_fqi->fq_last_comp); 143 if (rc != 0) { 144 smb_rename_release_src(sr); 145 return (smb_rename_errno2status(rc)); 146 } 147 } 148 149 dst_dnode = dst_fqi->fq_dnode; 150 new_name = dst_fqi->fq_last_comp; 151 152 /* If exact name match in same directory, we're done */ 153 if ((src_dnode == dst_dnode) && 154 (strcmp(src_fnode->od_name, new_name) == 0)) { 155 smb_rename_release_src(sr); 156 smb_node_release(dst_dnode); 157 return (0); 158 } 159 160 /* Lookup destination node */ 161 rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode, 162 dst_dnode, new_name, &dst_fqi->fq_fnode); 163 164 /* If the destination node doesn't already exist, validate new_name. */ 165 if (rc == ENOENT) { 166 if (smb_is_invalid_filename(new_name)) { 167 smb_rename_release_src(sr); 168 smb_node_release(dst_dnode); 169 return (NT_STATUS_OBJECT_NAME_INVALID); 170 } 171 } 172 173 /* 174 * Handle case where changing case of the same directory entry. 175 * 176 * If we found the dst node in the same directory as the src node, 177 * and their names differ only in case: 178 * 179 * If the tree is case sensitive (or mixed): 180 * Do case sensitive lookup to see if exact match exists. 181 * If the exact match is the same node as src_node we're done. 182 * 183 * If the tree is case insensitive: 184 * There is currently no way to tell if the case is different 185 * or not, so do the rename (unless the specified new name was 186 * mangled). 187 */ 188 if ((rc == 0) && 189 (src_dnode == dst_dnode) && 190 (smb_strcasecmp(src_fnode->od_name, 191 dst_fqi->fq_fnode->od_name, 0) == 0)) { 192 smb_node_release(dst_fqi->fq_fnode); 193 dst_fqi->fq_fnode = NULL; 194 195 if (smb_tree_has_feature(sr->tid_tree, 196 SMB_TREE_NO_CASESENSITIVE)) { 197 if (smb_strcasecmp(src_fnode->od_name, 198 dst_fqi->fq_last_comp, 0) != 0) { 199 smb_rename_release_src(sr); 200 smb_node_release(dst_dnode); 201 return (0); 202 } 203 } else { 204 rc = smb_fsop_lookup(sr, sr->user_cr, 205 SMB_CASE_SENSITIVE, tnode, dst_dnode, new_name, 206 &dst_fqi->fq_fnode); 207 208 if ((rc == 0) && 209 (dst_fqi->fq_fnode == src_fnode)) { 210 smb_rename_release_src(sr); 211 smb_node_release(dst_fqi->fq_fnode); 212 smb_node_release(dst_dnode); 213 return (0); 214 } 215 } 216 } 217 218 if ((rc != 0) && (rc != ENOENT)) { 219 smb_rename_release_src(sr); 220 smb_node_release(dst_fqi->fq_dnode); 221 return (smb_rename_errno2status(rc)); 222 } 223 224 if (dst_fqi->fq_fnode) { 225 /* 226 * Destination already exists. Do delete checks. 227 */ 228 dst_fnode = dst_fqi->fq_fnode; 229 230 if (!(sr->arg.dirop.flags && SMB_RENAME_FLAG_OVERWRITE)) { 231 smb_rename_release_src(sr); 232 smb_node_release(dst_fnode); 233 smb_node_release(dst_dnode); 234 return (NT_STATUS_OBJECT_NAME_COLLISION); 235 } 236 237 (void) smb_oplock_break(sr, dst_fnode, 238 SMB_OPLOCK_BREAK_TO_NONE | SMB_OPLOCK_BREAK_BATCH); 239 240 /* 241 * Wait (a little) for the oplock break to be 242 * responded to by clients closing handles. 243 * Hold node->n_lock as reader to keep new 244 * ofiles from showing up after we check. 245 */ 246 smb_node_rdlock(dst_fnode); 247 for (count = 0; count <= 12; count++) { 248 status = smb_node_delete_check(dst_fnode); 249 if (status != NT_STATUS_SHARING_VIOLATION) 250 break; 251 smb_node_unlock(dst_fnode); 252 delay(MSEC_TO_TICK(100)); 253 smb_node_rdlock(dst_fnode); 254 } 255 if (status != NT_STATUS_SUCCESS) { 256 smb_node_unlock(dst_fnode); 257 smb_rename_release_src(sr); 258 smb_node_release(dst_fnode); 259 smb_node_release(dst_dnode); 260 return (NT_STATUS_ACCESS_DENIED); 261 } 262 263 /* 264 * Note, the combination of these two: 265 * smb_node_rdlock(node); 266 * nbl_start_crit(node->vp, RW_READER); 267 * is equivalent to this call: 268 * smb_node_start_crit(node, RW_READER) 269 * 270 * Cleanup after this point should use: 271 * smb_node_end_crit(dst_fnode) 272 */ 273 nbl_start_crit(dst_fnode->vp, RW_READER); 274 275 /* 276 * This checks nbl_share_conflict, nbl_lock_conflict 277 */ 278 status = smb_nbl_conflict(dst_fnode, 0, UINT64_MAX, NBL_REMOVE); 279 if (status != NT_STATUS_SUCCESS) { 280 smb_node_end_crit(dst_fnode); 281 smb_rename_release_src(sr); 282 smb_node_release(dst_fnode); 283 smb_node_release(dst_dnode); 284 return (NT_STATUS_ACCESS_DENIED); 285 } 286 287 new_name = dst_fnode->od_name; 288 } 289 290 rc = smb_fsop_rename(sr, sr->user_cr, 291 src_dnode, src_fnode->od_name, 292 dst_dnode, new_name); 293 294 if (rc == 0) { 295 /* 296 * Note that renames in the same directory are normally 297 * delivered in {old,new} pairs, and clients expect them 298 * in that order, if both events are delivered. 299 */ 300 int a_src, a_dst; /* action codes */ 301 if (src_dnode == dst_dnode) { 302 a_src = FILE_ACTION_RENAMED_OLD_NAME; 303 a_dst = FILE_ACTION_RENAMED_NEW_NAME; 304 } else { 305 a_src = FILE_ACTION_REMOVED; 306 a_dst = FILE_ACTION_ADDED; 307 } 308 smb_node_notify_change(src_dnode, a_src, src_fnode->od_name); 309 smb_node_notify_change(dst_dnode, a_dst, new_name); 310 } 311 312 smb_rename_release_src(sr); 313 314 if (dst_fqi->fq_fnode) { 315 smb_node_end_crit(dst_fnode); 316 smb_node_release(dst_fnode); 317 } 318 smb_node_release(dst_dnode); 319 320 return (smb_rename_errno2status(rc)); 321 } 322 323 /* 324 * smb_rename_check_stream 325 * 326 * For a stream rename the dst path must begin with ':', or "\\:". 327 * We don't yet support stream rename, Return EACCES. 328 * 329 * If not a stream rename, in accordance with the above rule, 330 * it is not valid for either the src or dst to be a stream. 331 * Return EINVAL. 332 */ 333 static int 334 smb_rename_check_stream(smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi) 335 { 336 smb_node_t *src_fnode = src_fqi->fq_fnode; 337 char *src_path = src_fqi->fq_path.pn_path; 338 char *dst_path = dst_fqi->fq_path.pn_path; 339 340 /* We do not yet support named stream rename - ACCESS DENIED */ 341 if ((dst_path[0] == ':') || 342 ((dst_path[0] == '\\') && (dst_path[1] == ':'))) { 343 return (EACCES); 344 } 345 346 /* 347 * If not stream rename (above) neither src or dst can be 348 * a named stream. 349 */ 350 351 if (smb_is_stream_name(dst_path)) 352 return (EINVAL); 353 354 if (src_fqi->fq_fnode) { 355 if (SMB_IS_STREAM(src_fnode)) 356 return (EINVAL); 357 } else { 358 if (smb_is_stream_name(src_path)) 359 return (EINVAL); 360 } 361 362 return (0); 363 } 364 365 366 /* 367 * smb_setinfo_link 368 * 369 * Implements FileRenameInformation for SMB1 Trans2 setinfo, SMB2 setinfo. 370 * If the new filename (dst_fqi) already exists it may be overwritten 371 * if flags == 1. 372 * 373 * The passed path is a full path relative to the share root. 374 * 375 * Returns NT status codes. 376 * 377 * Similar to smb_setinfo_rename(), above. 378 */ 379 uint32_t 380 smb_setinfo_link(smb_request_t *sr, smb_node_t *node, char *path, int flags) 381 { 382 smb_fqi_t *src_fqi = &sr->arg.dirop.fqi; 383 smb_fqi_t *dst_fqi = &sr->arg.dirop.dst_fqi; 384 smb_pathname_t *dst_pn = &dst_fqi->fq_path; 385 uint32_t status; 386 387 sr->arg.dirop.flags = flags ? SMB_RENAME_FLAG_OVERWRITE : 0; 388 sr->arg.dirop.info_level = FileLinkInformation; 389 390 src_fqi->fq_sattr = SMB_SEARCH_ATTRIBUTES; 391 src_fqi->fq_fnode = node; 392 src_fqi->fq_dnode = node->n_dnode; 393 394 /* validate the dst pathname */ 395 smb_pathname_init(sr, dst_pn, path); 396 if (!smb_pathname_validate(sr, dst_pn)) 397 return (NT_STATUS_OBJECT_NAME_INVALID); 398 399 status = smb_make_link(sr, src_fqi, dst_fqi); 400 return (status); 401 } 402 403 /* 404 * smb_make_link 405 * 406 * Creating a hard link (adding an additional name) for a file. 407 * 408 * If the source and destination are identical, we go through all 409 * the checks but we don't create a link. 410 * 411 * If the file is a symlink we create the hardlink on the target 412 * of the symlink (i.e. use SMB_FOLLOW_LINKS when looking up src). 413 * If the target of the symlink does not exist we fail with ENOENT. 414 * 415 * Returns NT status values. 416 * 417 * Similar to smb_common_rename() above. 418 */ 419 uint32_t 420 smb_make_link(smb_request_t *sr, smb_fqi_t *src_fqi, smb_fqi_t *dst_fqi) 421 { 422 smb_node_t *tnode; 423 char *path; 424 int rc; 425 426 tnode = sr->tid_tree->t_snode; 427 path = dst_fqi->fq_path.pn_path; 428 429 /* Cannnot create link on named stream */ 430 if (smb_is_stream_name(src_fqi->fq_path.pn_path) || 431 smb_is_stream_name(dst_fqi->fq_path.pn_path)) { 432 return (NT_STATUS_INVALID_PARAMETER); 433 } 434 435 /* The source node may already have been provided */ 436 if (src_fqi->fq_fnode) { 437 smb_node_start_crit(src_fqi->fq_fnode, RW_READER); 438 smb_node_ref(src_fqi->fq_fnode); 439 smb_node_ref(src_fqi->fq_dnode); 440 } else { 441 /* lookup and validate src node */ 442 rc = smb_rename_lookup_src(sr); 443 if (rc != 0) 444 return (smb_rename_errno2status(rc)); 445 } 446 447 /* Not valid to create hardlink for directory */ 448 if (smb_node_is_dir(src_fqi->fq_fnode)) { 449 smb_rename_release_src(sr); 450 return (NT_STATUS_FILE_IS_A_DIRECTORY); 451 } 452 453 /* 454 * Find the destination dnode and last component. 455 * May already be provided, i.e. when called via 456 * SMB1 trans2 setinfo. 457 */ 458 if (dst_fqi->fq_dnode) { 459 smb_node_ref(dst_fqi->fq_dnode); 460 } else { 461 rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode, 462 &dst_fqi->fq_dnode, dst_fqi->fq_last_comp); 463 if (rc != 0) { 464 smb_rename_release_src(sr); 465 return (smb_rename_errno2status(rc)); 466 } 467 } 468 469 /* If CI name match in same directory, we're done */ 470 if ((src_fqi->fq_dnode == dst_fqi->fq_dnode) && 471 (smb_strcasecmp(src_fqi->fq_fnode->od_name, 472 dst_fqi->fq_last_comp, 0) == 0)) { 473 smb_rename_release_src(sr); 474 smb_node_release(dst_fqi->fq_dnode); 475 return (0); 476 } 477 478 if (smb_is_invalid_filename(dst_fqi->fq_last_comp)) { 479 smb_rename_release_src(sr); 480 smb_node_release(dst_fqi->fq_dnode); 481 return (NT_STATUS_OBJECT_NAME_INVALID); 482 } 483 484 /* Lookup the destination node. It MUST NOT exist. */ 485 rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode, 486 dst_fqi->fq_dnode, dst_fqi->fq_last_comp, &dst_fqi->fq_fnode); 487 if (rc == 0) { 488 smb_node_release(dst_fqi->fq_fnode); 489 rc = EEXIST; 490 } 491 if (rc != ENOENT) { 492 smb_rename_release_src(sr); 493 smb_node_release(dst_fqi->fq_dnode); 494 return (smb_rename_errno2status(rc)); 495 } 496 497 rc = smb_fsop_link(sr, sr->user_cr, src_fqi->fq_fnode, 498 dst_fqi->fq_dnode, dst_fqi->fq_last_comp); 499 500 if (rc == 0) { 501 smb_node_notify_change(dst_fqi->fq_dnode, 502 FILE_ACTION_ADDED, dst_fqi->fq_last_comp); 503 } 504 505 smb_rename_release_src(sr); 506 smb_node_release(dst_fqi->fq_dnode); 507 return (smb_rename_errno2status(rc)); 508 } 509 510 /* 511 * smb_rename_lookup_src 512 * 513 * Lookup the src node, checking for sharing violations and 514 * breaking any existing BATCH oplock. 515 * Populate sr->arg.dirop.fqi 516 * 517 * Upon success, the dnode and fnode will have holds and the 518 * fnode will be in a critical section. These should be 519 * released using smb_rename_release_src(). 520 * 521 * Returns errno values. 522 */ 523 static int 524 smb_rename_lookup_src(smb_request_t *sr) 525 { 526 smb_node_t *src_node, *tnode; 527 DWORD status; 528 int rc; 529 int count; 530 char *path; 531 532 smb_fqi_t *src_fqi = &sr->arg.dirop.fqi; 533 534 if (smb_is_stream_name(src_fqi->fq_path.pn_path)) 535 return (EINVAL); 536 537 /* Lookup the source node */ 538 tnode = sr->tid_tree->t_snode; 539 path = src_fqi->fq_path.pn_path; 540 rc = smb_pathname_reduce(sr, sr->user_cr, path, tnode, tnode, 541 &src_fqi->fq_dnode, src_fqi->fq_last_comp); 542 if (rc != 0) 543 return (rc); 544 545 rc = smb_fsop_lookup(sr, sr->user_cr, 0, tnode, 546 src_fqi->fq_dnode, src_fqi->fq_last_comp, &src_fqi->fq_fnode); 547 if (rc != 0) { 548 smb_node_release(src_fqi->fq_dnode); 549 return (rc); 550 } 551 src_node = src_fqi->fq_fnode; 552 553 rc = smb_rename_check_attr(sr, src_node, src_fqi->fq_sattr); 554 if (rc != 0) { 555 smb_node_release(src_fqi->fq_fnode); 556 smb_node_release(src_fqi->fq_dnode); 557 return (rc); 558 } 559 560 /* 561 * Break BATCH oplock before ofile checks. If a client 562 * has a file open, this will force a flush or close, 563 * which may affect the outcome of any share checking. 564 */ 565 (void) smb_oplock_break(sr, src_node, 566 SMB_OPLOCK_BREAK_TO_LEVEL_II | SMB_OPLOCK_BREAK_BATCH); 567 568 /* 569 * Wait (a little) for the oplock break to be 570 * responded to by clients closing handles. 571 * Hold node->n_lock as reader to keep new 572 * ofiles from showing up after we check. 573 */ 574 smb_node_rdlock(src_node); 575 for (count = 0; count <= 12; count++) { 576 status = smb_node_rename_check(src_node); 577 if (status != NT_STATUS_SHARING_VIOLATION) 578 break; 579 smb_node_unlock(src_node); 580 delay(MSEC_TO_TICK(100)); 581 smb_node_rdlock(src_node); 582 } 583 if (status != NT_STATUS_SUCCESS) { 584 smb_node_unlock(src_node); 585 smb_node_release(src_fqi->fq_fnode); 586 smb_node_release(src_fqi->fq_dnode); 587 return (EPIPE); /* = ERRbadshare */ 588 } 589 590 /* 591 * Note, the combination of these two: 592 * smb_node_rdlock(node); 593 * nbl_start_crit(node->vp, RW_READER); 594 * is equivalent to this call: 595 * smb_node_start_crit(node, RW_READER) 596 * 597 * Cleanup after this point should use: 598 * smb_node_end_crit(src_node) 599 */ 600 nbl_start_crit(src_node->vp, RW_READER); 601 602 /* 603 * This checks nbl_share_conflict, nbl_lock_conflict 604 */ 605 status = smb_nbl_conflict(src_node, 0, UINT64_MAX, NBL_RENAME); 606 if (status != NT_STATUS_SUCCESS) { 607 smb_node_end_crit(src_node); 608 smb_node_release(src_fqi->fq_fnode); 609 smb_node_release(src_fqi->fq_dnode); 610 if (status == NT_STATUS_SHARING_VIOLATION) 611 return (EPIPE); /* = ERRbadshare */ 612 return (EACCES); 613 } 614 615 /* NB: Caller expects holds on src_fqi fnode, dnode */ 616 return (0); 617 } 618 619 /* 620 * smb_rename_release_src 621 */ 622 static void 623 smb_rename_release_src(smb_request_t *sr) 624 { 625 smb_fqi_t *src_fqi = &sr->arg.dirop.fqi; 626 627 smb_node_end_crit(src_fqi->fq_fnode); 628 smb_node_release(src_fqi->fq_fnode); 629 smb_node_release(src_fqi->fq_dnode); 630 } 631 632 633 static int 634 smb_rename_check_attr(smb_request_t *sr, smb_node_t *node, uint16_t sattr) 635 { 636 smb_attr_t attr; 637 638 bzero(&attr, sizeof (attr)); 639 attr.sa_mask = SMB_AT_DOSATTR; 640 if (smb_node_getattr(sr, node, zone_kcred(), NULL, &attr) != 0) 641 return (EACCES); 642 643 if ((attr.sa_dosattr & FILE_ATTRIBUTE_HIDDEN) && 644 !(SMB_SEARCH_HIDDEN(sattr))) 645 return (ESRCH); 646 647 if ((attr.sa_dosattr & FILE_ATTRIBUTE_SYSTEM) && 648 !(SMB_SEARCH_SYSTEM(sattr))) 649 return (ESRCH); 650 651 return (0); 652 } 653 654 /* 655 * The following values are based on observed WFWG, Windows 9x, Windows NT 656 * and Windows 2000 behaviour. 657 * 658 * ERROR_FILE_EXISTS doesn't work for Windows 98 clients. 659 * 660 * Windows 95 clients don't see the problem because the target is deleted 661 * before the rename request. 662 */ 663 static uint32_t 664 smb_rename_errno2status(int errnum) 665 { 666 static struct { 667 int errnum; 668 uint32_t status32; 669 } rc_map[] = { 670 { EEXIST, NT_STATUS_OBJECT_NAME_COLLISION }, 671 { EPIPE, NT_STATUS_SHARING_VIOLATION }, 672 { ENOENT, NT_STATUS_OBJECT_NAME_NOT_FOUND }, 673 { ESRCH, NT_STATUS_NO_SUCH_FILE }, 674 { EINVAL, NT_STATUS_INVALID_PARAMETER }, 675 { EACCES, NT_STATUS_ACCESS_DENIED }, 676 { EISDIR, NT_STATUS_FILE_IS_A_DIRECTORY }, 677 { EIO, NT_STATUS_INTERNAL_ERROR } 678 }; 679 680 int i; 681 682 if (errnum == 0) 683 return (0); 684 685 for (i = 0; i < sizeof (rc_map)/sizeof (rc_map[0]); ++i) { 686 if (rc_map[i].errnum == errnum) { 687 return (rc_map[i].status32); 688 } 689 } 690 691 return (smb_errno2status(errnum)); 692 } 693