1/* 2 Unix SMB/CIFS implementation. 3 file closing 4 Copyright (C) Andrew Tridgell 1992-1998 5 Copyright (C) Jeremy Allison 1992-2007. 6 Copyright (C) Volker Lendecke 2005 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. 20*/ 21 22#include "includes.h" 23 24extern struct current_user current_user; 25 26/**************************************************************************** 27 Run a file if it is a magic script. 28****************************************************************************/ 29 30static NTSTATUS check_magic(struct files_struct *fsp) 31{ 32 int ret; 33 const char *magic_output = NULL; 34 SMB_STRUCT_STAT st; 35 int tmp_fd, outfd; 36 TALLOC_CTX *ctx = NULL; 37 const char *p; 38 struct connection_struct *conn = fsp->conn; 39 char *fname = NULL; 40 NTSTATUS status; 41 42 if (!*lp_magicscript(SNUM(conn))) { 43 return NT_STATUS_OK; 44 } 45 46 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp))); 47 48 ctx = talloc_stackframe(); 49 50 fname = fsp->fsp_name->base_name; 51 52 if (!(p = strrchr_m(fname,'/'))) { 53 p = fname; 54 } else { 55 p++; 56 } 57 58 if (!strequal(lp_magicscript(SNUM(conn)),p)) { 59 status = NT_STATUS_OK; 60 goto out; 61 } 62 63 if (*lp_magicoutput(SNUM(conn))) { 64 magic_output = lp_magicoutput(SNUM(conn)); 65 } else { 66 magic_output = talloc_asprintf(ctx, 67 "%s.out", 68 fname); 69 } 70 if (!magic_output) { 71 status = NT_STATUS_NO_MEMORY; 72 goto out; 73 } 74 75 /* Ensure we don't depend on user's PATH. */ 76 p = talloc_asprintf(ctx, "./%s", fname); 77 if (!p) { 78 status = NT_STATUS_NO_MEMORY; 79 goto out; 80 } 81 82 if (chmod(fname, 0755) == -1) { 83 status = map_nt_error_from_unix(errno); 84 goto out; 85 } 86 ret = smbrun(p,&tmp_fd); 87 DEBUG(3,("Invoking magic command %s gave %d\n", 88 p,ret)); 89 90 unlink(fname); 91 if (ret != 0 || tmp_fd == -1) { 92 if (tmp_fd != -1) { 93 close(tmp_fd); 94 } 95 status = NT_STATUS_UNSUCCESSFUL; 96 goto out; 97 } 98 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600); 99 if (outfd == -1) { 100 int err = errno; 101 close(tmp_fd); 102 status = map_nt_error_from_unix(err); 103 goto out; 104 } 105 106 if (sys_fstat(tmp_fd, &st, false) == -1) { 107 int err = errno; 108 close(tmp_fd); 109 close(outfd); 110 status = map_nt_error_from_unix(err); 111 goto out; 112 } 113 114 if (transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_ex_size) == (SMB_OFF_T)-1) { 115 int err = errno; 116 close(tmp_fd); 117 close(outfd); 118 status = map_nt_error_from_unix(err); 119 goto out; 120 } 121 close(tmp_fd); 122 if (close(outfd) == -1) { 123 status = map_nt_error_from_unix(errno); 124 goto out; 125 } 126 127 status = NT_STATUS_OK; 128 129 out: 130 TALLOC_FREE(ctx); 131 return status; 132} 133 134/**************************************************************************** 135 Common code to close a file or a directory. 136****************************************************************************/ 137 138static NTSTATUS close_filestruct(files_struct *fsp) 139{ 140 NTSTATUS status = NT_STATUS_OK; 141 142 if (fsp->fh->fd != -1) { 143 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) { 144 status = map_nt_error_from_unix(errno); 145 } 146 delete_write_cache(fsp); 147 } 148 149 return status; 150} 151 152/**************************************************************************** 153 If any deferred opens are waiting on this close, notify them. 154****************************************************************************/ 155 156static void notify_deferred_opens(struct share_mode_lock *lck) 157{ 158 int i; 159 160 if (!should_notify_deferred_opens()) { 161 return; 162 } 163 164 for (i=0; i<lck->num_share_modes; i++) { 165 struct share_mode_entry *e = &lck->share_modes[i]; 166 167 if (!is_deferred_open_entry(e)) { 168 continue; 169 } 170 171 if (procid_is_me(&e->pid)) { 172 /* 173 * We need to notify ourself to retry the open. Do 174 * this by finding the queued SMB record, moving it to 175 * the head of the queue and changing the wait time to 176 * zero. 177 */ 178 schedule_deferred_open_smb_message(e->op_mid); 179 } else { 180 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE]; 181 182 share_mode_entry_to_message(msg, e); 183 184 messaging_send_buf(smbd_messaging_context(), 185 e->pid, MSG_SMB_OPEN_RETRY, 186 (uint8 *)msg, 187 MSG_SMB_SHARE_MODE_ENTRY_SIZE); 188 } 189 } 190} 191 192/**************************************************************************** 193 Delete all streams 194****************************************************************************/ 195 196NTSTATUS delete_all_streams(connection_struct *conn, const char *fname) 197{ 198 struct stream_struct *stream_info; 199 int i; 200 unsigned int num_streams; 201 TALLOC_CTX *frame = talloc_stackframe(); 202 NTSTATUS status; 203 204 status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(), 205 &num_streams, &stream_info); 206 207 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) { 208 DEBUG(10, ("no streams around\n")); 209 TALLOC_FREE(frame); 210 return NT_STATUS_OK; 211 } 212 213 if (!NT_STATUS_IS_OK(status)) { 214 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n", 215 nt_errstr(status))); 216 goto fail; 217 } 218 219 DEBUG(10, ("delete_all_streams found %d streams\n", 220 num_streams)); 221 222 if (num_streams == 0) { 223 TALLOC_FREE(frame); 224 return NT_STATUS_OK; 225 } 226 227 for (i=0; i<num_streams; i++) { 228 int res; 229 struct smb_filename *smb_fname_stream = NULL; 230 231 if (strequal(stream_info[i].name, "::$DATA")) { 232 continue; 233 } 234 235 status = create_synthetic_smb_fname(talloc_tos(), fname, 236 stream_info[i].name, NULL, 237 &smb_fname_stream); 238 239 if (!NT_STATUS_IS_OK(status)) { 240 DEBUG(0, ("talloc_aprintf failed\n")); 241 goto fail; 242 } 243 244 res = SMB_VFS_UNLINK(conn, smb_fname_stream); 245 246 if (res == -1) { 247 status = map_nt_error_from_unix(errno); 248 DEBUG(10, ("Could not delete stream %s: %s\n", 249 smb_fname_str_dbg(smb_fname_stream), 250 strerror(errno))); 251 TALLOC_FREE(smb_fname_stream); 252 break; 253 } 254 TALLOC_FREE(smb_fname_stream); 255 } 256 257 fail: 258 TALLOC_FREE(frame); 259 return status; 260} 261 262/**************************************************************************** 263 Deal with removing a share mode on last close. 264****************************************************************************/ 265 266static NTSTATUS close_remove_share_mode(files_struct *fsp, 267 enum file_close_type close_type) 268{ 269 connection_struct *conn = fsp->conn; 270 bool delete_file = false; 271 bool changed_user = false; 272 struct share_mode_lock *lck = NULL; 273 NTSTATUS status = NT_STATUS_OK; 274 NTSTATUS tmp_status; 275 struct file_id id; 276 277 /* Ensure any pending write time updates are done. */ 278 if (fsp->update_write_time_event) { 279 update_write_time_handler(smbd_event_context(), 280 fsp->update_write_time_event, 281 timeval_current(), 282 (void *)fsp); 283 } 284 285 /* 286 * Lock the share entries, and determine if we should delete 287 * on close. If so delete whilst the lock is still in effect. 288 * This prevents race conditions with the file being created. JRA. 289 */ 290 291 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL, 292 NULL); 293 294 if (lck == NULL) { 295 DEBUG(0, ("close_remove_share_mode: Could not get share mode " 296 "lock for file %s\n", fsp_str_dbg(fsp))); 297 status = NT_STATUS_INVALID_PARAMETER; 298 goto done; 299 } 300 301 if (fsp->write_time_forced) { 302 DEBUG(10,("close_remove_share_mode: write time forced " 303 "for file %s\n", 304 fsp_str_dbg(fsp))); 305 set_close_write_time(fsp, lck->changed_write_time); 306 } else if (fsp->update_write_time_on_close) { 307 /* Someone had a pending write. */ 308 if (null_timespec(fsp->close_write_time)) { 309 DEBUG(10,("close_remove_share_mode: update to current time " 310 "for file %s\n", 311 fsp_str_dbg(fsp))); 312 /* Update to current time due to "normal" write. */ 313 set_close_write_time(fsp, timespec_current()); 314 } else { 315 DEBUG(10,("close_remove_share_mode: write time pending " 316 "for file %s\n", 317 fsp_str_dbg(fsp))); 318 /* Update to time set on close call. */ 319 set_close_write_time(fsp, fsp->close_write_time); 320 } 321 } 322 323 if (!del_share_mode(lck, fsp)) { 324 DEBUG(0, ("close_remove_share_mode: Could not delete share " 325 "entry for file %s\n", 326 fsp_str_dbg(fsp))); 327 } 328 329 if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) { 330 bool became_user = False; 331 332 /* Initial delete on close was set and no one else 333 * wrote a real delete on close. */ 334 335 if (current_user.vuid != fsp->vuid) { 336 become_user(conn, fsp->vuid); 337 became_user = True; 338 } 339 fsp->delete_on_close = true; 340 set_delete_on_close_lck(lck, True, ¤t_user.ut); 341 if (became_user) { 342 unbecome_user(); 343 } 344 } 345 346 delete_file = lck->delete_on_close; 347 348 if (delete_file) { 349 int i; 350 /* See if others still have the file open. If this is the 351 * case, then don't delete. If all opens are POSIX delete now. */ 352 for (i=0; i<lck->num_share_modes; i++) { 353 struct share_mode_entry *e = &lck->share_modes[i]; 354 if (is_valid_share_mode_entry(e)) { 355 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) { 356 continue; 357 } 358 delete_file = False; 359 break; 360 } 361 } 362 } 363 364 /* Notify any deferred opens waiting on this close. */ 365 notify_deferred_opens(lck); 366 reply_to_oplock_break_requests(fsp); 367 368 /* 369 * NT can set delete_on_close of the last open 370 * reference to a file. 371 */ 372 373 if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) 374 || !delete_file 375 || (lck->delete_token == NULL)) { 376 TALLOC_FREE(lck); 377 return NT_STATUS_OK; 378 } 379 380 /* 381 * Ok, we have to delete the file 382 */ 383 384 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set " 385 "- deleting file.\n", fsp_str_dbg(fsp))); 386 387 /* 388 * Don't try to update the write time when we delete the file 389 */ 390 fsp->update_write_time_on_close = false; 391 392 if (!unix_token_equal(lck->delete_token, ¤t_user.ut)) { 393 /* Become the user who requested the delete. */ 394 395 DEBUG(5,("close_remove_share_mode: file %s. " 396 "Change user to uid %u\n", 397 fsp_str_dbg(fsp), 398 (unsigned int)lck->delete_token->uid)); 399 400 if (!push_sec_ctx()) { 401 smb_panic("close_remove_share_mode: file %s. failed to push " 402 "sec_ctx.\n"); 403 } 404 405 set_sec_ctx(lck->delete_token->uid, 406 lck->delete_token->gid, 407 lck->delete_token->ngroups, 408 lck->delete_token->groups, 409 NULL); 410 411 changed_user = true; 412 } 413 414 /* We can only delete the file if the name we have is still valid and 415 hasn't been renamed. */ 416 417 tmp_status = vfs_stat_fsp(fsp); 418 if (!NT_STATUS_IS_OK(tmp_status)) { 419 DEBUG(5,("close_remove_share_mode: file %s. Delete on close " 420 "was set and stat failed with error %s\n", 421 fsp_str_dbg(fsp), nt_errstr(tmp_status))); 422 /* 423 * Don't save the errno here, we ignore this error 424 */ 425 goto done; 426 } 427 428 id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st); 429 430 if (!file_id_equal(&fsp->file_id, &id)) { 431 DEBUG(5,("close_remove_share_mode: file %s. Delete on close " 432 "was set and dev and/or inode does not match\n", 433 fsp_str_dbg(fsp))); 434 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, " 435 "stat file_id %s\n", 436 fsp_str_dbg(fsp), 437 file_id_string_tos(&fsp->file_id), 438 file_id_string_tos(&id))); 439 /* 440 * Don't save the errno here, we ignore this error 441 */ 442 goto done; 443 } 444 445 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) 446 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) { 447 448 status = delete_all_streams(conn, fsp->fsp_name->base_name); 449 450 if (!NT_STATUS_IS_OK(status)) { 451 DEBUG(5, ("delete_all_streams failed: %s\n", 452 nt_errstr(status))); 453 goto done; 454 } 455 } 456 457 458 if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) { 459 /* 460 * This call can potentially fail as another smbd may 461 * have had the file open with delete on close set and 462 * deleted it when its last reference to this file 463 * went away. Hence we log this but not at debug level 464 * zero. 465 */ 466 467 DEBUG(5,("close_remove_share_mode: file %s. Delete on close " 468 "was set and unlink failed with error %s\n", 469 fsp_str_dbg(fsp), strerror(errno))); 470 471 status = map_nt_error_from_unix(errno); 472 } 473 474 notify_fname(conn, NOTIFY_ACTION_REMOVED, 475 FILE_NOTIFY_CHANGE_FILE_NAME, 476 fsp->fsp_name->base_name); 477 478 /* As we now have POSIX opens which can unlink 479 * with other open files we may have taken 480 * this code path with more than one share mode 481 * entry - ensure we only delete once by resetting 482 * the delete on close flag. JRA. 483 */ 484 485 fsp->delete_on_close = false; 486 set_delete_on_close_lck(lck, False, NULL); 487 488 done: 489 490 if (changed_user) { 491 /* unbecome user. */ 492 pop_sec_ctx(); 493 } 494 495 TALLOC_FREE(lck); 496 return status; 497} 498 499void set_close_write_time(struct files_struct *fsp, struct timespec ts) 500{ 501 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts)))); 502 503 if (null_timespec(ts)) { 504 return; 505 } 506 fsp->write_time_forced = false; 507 fsp->update_write_time_on_close = true; 508 fsp->close_write_time = ts; 509} 510 511static NTSTATUS update_write_time_on_close(struct files_struct *fsp) 512{ 513 struct smb_file_time ft; 514 NTSTATUS status; 515 struct share_mode_lock *lck = NULL; 516 517 ZERO_STRUCT(ft); 518 519 if (!fsp->update_write_time_on_close) { 520 return NT_STATUS_OK; 521 } 522 523 if (null_timespec(fsp->close_write_time)) { 524 fsp->close_write_time = timespec_current(); 525 } 526 527 /* Ensure we have a valid stat struct for the source. */ 528 status = vfs_stat_fsp(fsp); 529 if (!NT_STATUS_IS_OK(status)) { 530 return status; 531 } 532 533 if (!VALID_STAT(fsp->fsp_name->st)) { 534 /* if it doesn't seem to be a real file */ 535 return NT_STATUS_OK; 536 } 537 538 /* On close if we're changing the real file time we 539 * must update it in the open file db too. */ 540 (void)set_write_time(fsp->file_id, fsp->close_write_time); 541 542 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL, NULL); 543 if (lck) { 544 /* Close write times overwrite sticky write times 545 so we must replace any sticky write time here. */ 546 if (!null_timespec(lck->changed_write_time)) { 547 (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time); 548 } 549 TALLOC_FREE(lck); 550 } 551 552 ft.mtime = fsp->close_write_time; 553 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false); 554 if (!NT_STATUS_IS_OK(status)) { 555 return status; 556 } 557 558 return status; 559} 560 561static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2) 562{ 563 if (!NT_STATUS_IS_OK(s1)) { 564 return s1; 565 } 566 return s2; 567} 568 569/**************************************************************************** 570 Close a file. 571 572 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE. 573 printing and magic scripts are only run on normal close. 574 delete on close is done on normal and shutdown close. 575****************************************************************************/ 576 577static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp, 578 enum file_close_type close_type) 579{ 580 NTSTATUS status = NT_STATUS_OK; 581 NTSTATUS tmp; 582 connection_struct *conn = fsp->conn; 583 584 if (fsp->aio_write_behind) { 585 /* 586 * If we're finishing write behind on a close we can get a write 587 * error here, we must remember this. 588 */ 589 int ret = wait_for_aio_completion(fsp); 590 if (ret) { 591 status = ntstatus_keeperror( 592 status, map_nt_error_from_unix(ret)); 593 } 594 } else { 595 cancel_aio_by_fsp(fsp); 596 } 597 598 /* 599 * If we're flushing on a close we can get a write 600 * error here, we must remember this. 601 */ 602 603 tmp = close_filestruct(fsp); 604 status = ntstatus_keeperror(status, tmp); 605 606 if (fsp->print_file) { 607 print_fsp_end(fsp, close_type); 608 file_free(req, fsp); 609 return NT_STATUS_OK; 610 } 611 612 /* Remove the oplock before potentially deleting the file. */ 613 if(fsp->oplock_type) { 614 release_file_oplock(fsp); 615 } 616 617 /* If this is an old DOS or FCB open and we have multiple opens on 618 the same handle we only have one share mode. Ensure we only remove 619 the share mode on the last close. */ 620 621 if (fsp->fh->ref_count == 1) { 622 /* Should we return on error here... ? */ 623 tmp = close_remove_share_mode(fsp, close_type); 624 status = ntstatus_keeperror(status, tmp); 625 } 626 627 locking_close_file(smbd_messaging_context(), fsp); 628 629 tmp = fd_close(fsp); 630 status = ntstatus_keeperror(status, tmp); 631 632 /* check for magic scripts */ 633 if (close_type == NORMAL_CLOSE) { 634 tmp = check_magic(fsp); 635 status = ntstatus_keeperror(status, tmp); 636 } 637 638 /* 639 * Ensure pending modtime is set after close. 640 */ 641 642 tmp = update_write_time_on_close(fsp); 643 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { 644 /* Someone renamed the file or a parent directory containing 645 * this file. We can't do anything about this, we don't have 646 * an "update timestamp by fd" call in POSIX. Eat the error. */ 647 648 tmp = NT_STATUS_OK; 649 } 650 651 status = ntstatus_keeperror(status, tmp); 652 653 DEBUG(2,("%s closed file %s (numopen=%d) %s\n", 654 conn->server_info->unix_name, fsp_str_dbg(fsp), 655 conn->num_files_open - 1, 656 nt_errstr(status) )); 657 658 file_free(req, fsp); 659 return status; 660} 661/**************************************************************************** 662 Static function used by reply_rmdir to delete an entire directory 663 tree recursively. Return True on ok, False on fail. 664****************************************************************************/ 665 666static bool recursive_rmdir(TALLOC_CTX *ctx, 667 connection_struct *conn, 668 struct smb_filename *smb_dname) 669{ 670 const char *dname = NULL; 671 char *talloced = NULL; 672 bool ret = True; 673 long offset = 0; 674 SMB_STRUCT_STAT st; 675 struct smb_Dir *dir_hnd; 676 677 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname)); 678 679 dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0); 680 if(dir_hnd == NULL) 681 return False; 682 683 while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) { 684 struct smb_filename *smb_dname_full = NULL; 685 char *fullname = NULL; 686 bool do_break = true; 687 NTSTATUS status; 688 689 if (ISDOT(dname) || ISDOTDOT(dname)) { 690 TALLOC_FREE(talloced); 691 continue; 692 } 693 694 if (!is_visible_file(conn, smb_dname->base_name, dname, &st, 695 false)) { 696 TALLOC_FREE(talloced); 697 continue; 698 } 699 700 /* Construct the full name. */ 701 fullname = talloc_asprintf(ctx, 702 "%s/%s", 703 smb_dname->base_name, 704 dname); 705 if (!fullname) { 706 errno = ENOMEM; 707 goto err_break; 708 } 709 710 status = create_synthetic_smb_fname(talloc_tos(), fullname, 711 NULL, NULL, 712 &smb_dname_full); 713 if (!NT_STATUS_IS_OK(status)) { 714 goto err_break; 715 } 716 717 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) { 718 goto err_break; 719 } 720 721 if(smb_dname_full->st.st_ex_mode & S_IFDIR) { 722 if(!recursive_rmdir(ctx, conn, smb_dname_full)) { 723 goto err_break; 724 } 725 if(SMB_VFS_RMDIR(conn, 726 smb_dname_full->base_name) != 0) { 727 goto err_break; 728 } 729 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) { 730 goto err_break; 731 } 732 733 /* Successful iteration. */ 734 do_break = false; 735 736 err_break: 737 TALLOC_FREE(smb_dname_full); 738 TALLOC_FREE(fullname); 739 TALLOC_FREE(talloced); 740 if (do_break) { 741 ret = false; 742 break; 743 } 744 } 745 TALLOC_FREE(dir_hnd); 746 return ret; 747} 748 749/**************************************************************************** 750 The internals of the rmdir code - called elsewhere. 751****************************************************************************/ 752 753static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp) 754{ 755 connection_struct *conn = fsp->conn; 756 struct smb_filename *smb_dname = fsp->fsp_name; 757 int ret; 758 759 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname)); 760 761 /* Might be a symlink. */ 762 if(SMB_VFS_LSTAT(conn, smb_dname) != 0) { 763 return map_nt_error_from_unix(errno); 764 } 765 766 if (S_ISLNK(smb_dname->st.st_ex_mode)) { 767 /* Is what it points to a directory ? */ 768 if(SMB_VFS_STAT(conn, smb_dname) != 0) { 769 return map_nt_error_from_unix(errno); 770 } 771 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) { 772 return NT_STATUS_NOT_A_DIRECTORY; 773 } 774 ret = SMB_VFS_UNLINK(conn, smb_dname); 775 } else { 776 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name); 777 } 778 if (ret == 0) { 779 notify_fname(conn, NOTIFY_ACTION_REMOVED, 780 FILE_NOTIFY_CHANGE_DIR_NAME, 781 smb_dname->base_name); 782 return NT_STATUS_OK; 783 } 784 785 if(((errno == ENOTEMPTY)||(errno == EEXIST)) && lp_veto_files(SNUM(conn))) { 786 /* 787 * Check to see if the only thing in this directory are 788 * vetoed files/directories. If so then delete them and 789 * retry. If we fail to delete any of them (and we *don't* 790 * do a recursive delete) then fail the rmdir. 791 */ 792 SMB_STRUCT_STAT st; 793 const char *dname = NULL; 794 char *talloced = NULL; 795 long dirpos = 0; 796 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, 797 smb_dname->base_name, NULL, 798 0); 799 800 if(dir_hnd == NULL) { 801 errno = ENOTEMPTY; 802 goto err; 803 } 804 805 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, 806 &talloced)) != NULL) { 807 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) { 808 TALLOC_FREE(talloced); 809 continue; 810 } 811 if (!is_visible_file(conn, smb_dname->base_name, dname, 812 &st, false)) { 813 TALLOC_FREE(talloced); 814 continue; 815 } 816 if(!IS_VETO_PATH(conn, dname)) { 817 TALLOC_FREE(dir_hnd); 818 TALLOC_FREE(talloced); 819 errno = ENOTEMPTY; 820 goto err; 821 } 822 TALLOC_FREE(talloced); 823 } 824 825 /* We only have veto files/directories. 826 * Are we allowed to delete them ? */ 827 828 if(!lp_recursive_veto_delete(SNUM(conn))) { 829 TALLOC_FREE(dir_hnd); 830 errno = ENOTEMPTY; 831 goto err; 832 } 833 834 /* Do a recursive delete. */ 835 RewindDir(dir_hnd,&dirpos); 836 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, 837 &talloced)) != NULL) { 838 struct smb_filename *smb_dname_full = NULL; 839 char *fullname = NULL; 840 bool do_break = true; 841 NTSTATUS status; 842 843 if (ISDOT(dname) || ISDOTDOT(dname)) { 844 TALLOC_FREE(talloced); 845 continue; 846 } 847 if (!is_visible_file(conn, smb_dname->base_name, dname, 848 &st, false)) { 849 TALLOC_FREE(talloced); 850 continue; 851 } 852 853 fullname = talloc_asprintf(ctx, 854 "%s/%s", 855 smb_dname->base_name, 856 dname); 857 858 if(!fullname) { 859 errno = ENOMEM; 860 goto err_break; 861 } 862 863 status = create_synthetic_smb_fname(talloc_tos(), 864 fullname, NULL, 865 NULL, 866 &smb_dname_full); 867 if (!NT_STATUS_IS_OK(status)) { 868 errno = map_errno_from_nt_status(status); 869 goto err_break; 870 } 871 872 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) { 873 goto err_break; 874 } 875 if(smb_dname_full->st.st_ex_mode & S_IFDIR) { 876 if(!recursive_rmdir(ctx, conn, 877 smb_dname_full)) { 878 goto err_break; 879 } 880 if(SMB_VFS_RMDIR(conn, 881 smb_dname_full->base_name) != 0) { 882 goto err_break; 883 } 884 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) { 885 goto err_break; 886 } 887 888 /* Successful iteration. */ 889 do_break = false; 890 891 err_break: 892 TALLOC_FREE(fullname); 893 TALLOC_FREE(smb_dname_full); 894 TALLOC_FREE(talloced); 895 if (do_break) 896 break; 897 } 898 TALLOC_FREE(dir_hnd); 899 /* Retry the rmdir */ 900 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name); 901 } 902 903 err: 904 905 if (ret != 0) { 906 DEBUG(3,("rmdir_internals: couldn't remove directory %s : " 907 "%s\n", smb_fname_str_dbg(smb_dname), 908 strerror(errno))); 909 return map_nt_error_from_unix(errno); 910 } 911 912 notify_fname(conn, NOTIFY_ACTION_REMOVED, 913 FILE_NOTIFY_CHANGE_DIR_NAME, 914 smb_dname->base_name); 915 916 return NT_STATUS_OK; 917} 918 919/**************************************************************************** 920 Close a directory opened by an NT SMB call. 921****************************************************************************/ 922 923static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp, 924 enum file_close_type close_type) 925{ 926 struct share_mode_lock *lck = NULL; 927 bool delete_dir = False; 928 NTSTATUS status = NT_STATUS_OK; 929 NTSTATUS status1 = NT_STATUS_OK; 930 931 /* 932 * NT can set delete_on_close of the last open 933 * reference to a directory also. 934 */ 935 936 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL, 937 NULL); 938 939 if (lck == NULL) { 940 DEBUG(0, ("close_directory: Could not get share mode lock for " 941 "%s\n", fsp_str_dbg(fsp))); 942 status = NT_STATUS_INVALID_PARAMETER; 943 goto out; 944 } 945 946 if (!del_share_mode(lck, fsp)) { 947 DEBUG(0, ("close_directory: Could not delete share entry for " 948 "%s\n", fsp_str_dbg(fsp))); 949 } 950 951 if (fsp->initial_delete_on_close) { 952 bool became_user = False; 953 954 /* Initial delete on close was set - for 955 * directories we don't care if anyone else 956 * wrote a real delete on close. */ 957 958 if (current_user.vuid != fsp->vuid) { 959 become_user(fsp->conn, fsp->vuid); 960 became_user = True; 961 } 962 send_stat_cache_delete_message(fsp->fsp_name->base_name); 963 set_delete_on_close_lck(lck, True, ¤t_user.ut); 964 fsp->delete_on_close = true; 965 if (became_user) { 966 unbecome_user(); 967 } 968 } 969 970 delete_dir = lck->delete_on_close; 971 972 if (delete_dir) { 973 int i; 974 /* See if others still have the dir open. If this is the 975 * case, then don't delete. If all opens are POSIX delete now. */ 976 for (i=0; i<lck->num_share_modes; i++) { 977 struct share_mode_entry *e = &lck->share_modes[i]; 978 if (is_valid_share_mode_entry(e)) { 979 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) { 980 continue; 981 } 982 delete_dir = False; 983 break; 984 } 985 } 986 } 987 988 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) && 989 delete_dir && 990 lck->delete_token) { 991 992 /* Become the user who requested the delete. */ 993 994 if (!push_sec_ctx()) { 995 smb_panic("close_directory: failed to push sec_ctx.\n"); 996 } 997 998 set_sec_ctx(lck->delete_token->uid, 999 lck->delete_token->gid, 1000 lck->delete_token->ngroups, 1001 lck->delete_token->groups, 1002 NULL); 1003 1004 TALLOC_FREE(lck); 1005 1006 status = rmdir_internals(talloc_tos(), fsp); 1007 1008 DEBUG(5,("close_directory: %s. Delete on close was set - " 1009 "deleting directory returned %s.\n", 1010 fsp_str_dbg(fsp), nt_errstr(status))); 1011 1012 /* unbecome user. */ 1013 pop_sec_ctx(); 1014 1015 /* 1016 * Ensure we remove any change notify requests that would 1017 * now fail as the directory has been deleted. 1018 */ 1019 1020 if(NT_STATUS_IS_OK(status)) { 1021 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING); 1022 } 1023 } else { 1024 TALLOC_FREE(lck); 1025 remove_pending_change_notify_requests_by_fid( 1026 fsp, NT_STATUS_OK); 1027 } 1028 1029 status1 = fd_close(fsp); 1030 1031 if (!NT_STATUS_IS_OK(status1)) { 1032 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n", 1033 fsp_str_dbg(fsp), fsp->fh->fd, errno, 1034 strerror(errno))); 1035 } 1036 1037 if (fsp->dptr) { 1038 dptr_CloseDir(fsp->dptr); 1039 } 1040 1041 /* 1042 * Do the code common to files and directories. 1043 */ 1044 close_filestruct(fsp); 1045 file_free(req, fsp); 1046 1047 out: 1048 TALLOC_FREE(lck); 1049 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) { 1050 status = status1; 1051 } 1052 return status; 1053} 1054 1055/**************************************************************************** 1056 Close a files_struct. 1057****************************************************************************/ 1058 1059NTSTATUS close_file(struct smb_request *req, files_struct *fsp, 1060 enum file_close_type close_type) 1061{ 1062 NTSTATUS status; 1063 struct files_struct *base_fsp = fsp->base_fsp; 1064 1065 if(fsp->is_directory) { 1066 status = close_directory(req, fsp, close_type); 1067 } else if (fsp->fake_file_handle != NULL) { 1068 status = close_fake_file(req, fsp); 1069 } else { 1070 status = close_normal_file(req, fsp, close_type); 1071 } 1072 1073 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) { 1074 1075 /* 1076 * fsp was a stream, the base fsp can't be a stream as well 1077 * 1078 * For SHUTDOWN_CLOSE this is not possible here, because 1079 * SHUTDOWN_CLOSE only happens from files.c which walks the 1080 * complete list of files. If we mess with more than one fsp 1081 * those loops will become confused. 1082 */ 1083 1084 SMB_ASSERT(base_fsp->base_fsp == NULL); 1085 close_file(req, base_fsp, close_type); 1086 } 1087 1088 return status; 1089} 1090 1091/**************************************************************************** 1092 Deal with an (authorized) message to close a file given the share mode 1093 entry. 1094****************************************************************************/ 1095 1096void msg_close_file(struct messaging_context *msg_ctx, 1097 void *private_data, 1098 uint32_t msg_type, 1099 struct server_id server_id, 1100 DATA_BLOB *data) 1101{ 1102 files_struct *fsp = NULL; 1103 struct share_mode_entry e; 1104 1105 message_to_share_mode_entry(&e, (char *)data->data); 1106 1107 if(DEBUGLVL(10)) { 1108 char *sm_str = share_mode_str(NULL, 0, &e); 1109 if (!sm_str) { 1110 smb_panic("talloc failed"); 1111 } 1112 DEBUG(10,("msg_close_file: got request to close share mode " 1113 "entry %s\n", sm_str)); 1114 TALLOC_FREE(sm_str); 1115 } 1116 1117 fsp = file_find_dif(e.id, e.share_file_id); 1118 if (!fsp) { 1119 DEBUG(10,("msg_close_file: failed to find file.\n")); 1120 return; 1121 } 1122 close_file(NULL, fsp, NORMAL_CLOSE); 1123} 1124