source3/smbd/open.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file opening and share modes
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 2001
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern userdom_struct current_user_info;
  25 extern uint16 global_oplock_port;
  26 extern BOOL global_client_failed_oplock_break;
  27
  28 /****************************************************************************
  29  fd support routines - attempt to do a dos_open.
  30 ****************************************************************************/
  31
  32 static int fd_open(struct connection_struct *conn, char *fname,
  33                    int flags, mode_t mode)
  34 {
  35         int fd;
  36 #ifdef O_NOFOLLOW
  37         if (!lp_symlinks(SNUM(conn)))
  38                 flags |= O_NOFOLLOW;
  39 #endif
  40
  41         fd = VFS_OPEN(conn,fname,flags,mode);
  42
  43         /* Fix for files ending in '.' */
  44         if((fd == -1) && (errno == ENOENT) &&
  45            (strchr_m(fname,'.')==NULL)) {
  46                 pstrcat(fname,".");
  47                 fd = VFS_OPEN(conn,fname,flags,mode);
  48         }
  49
  50         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
  51                 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
  52
  53         return fd;
  54 }
  55
  56 /****************************************************************************
  57  Close the file associated with a fsp.
  58 ****************************************************************************/
  59
  60 int fd_close(struct connection_struct *conn, files_struct *fsp)
  61 {
  62         if (fsp->fd == -1)
  63                 return 0; /* what we used to call a stat open. */
  64         return fd_close_posix(conn, fsp);
  65 }
  66
  67
  68 /****************************************************************************
  69  Check a filename for the pipe string.
  70 ****************************************************************************/
  71
  72 static void check_for_pipe(char *fname)
  73 {
  74         /* special case of pipe opens */
  75         char s[10];
  76         StrnCpy(s,fname,sizeof(s)-1);
  77         strlower(s);
  78         if (strstr(s,"pipe/")) {
  79                 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
  80                 unix_ERR_class = ERRSRV;
  81                 unix_ERR_code = ERRaccess;
  82                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
  83         }
  84 }
  85
  86 /****************************************************************************
  87  Open a file.
  88 ****************************************************************************/
  89
  90 static BOOL open_file(files_struct *fsp,connection_struct *conn,
  91                       const char *fname1,SMB_STRUCT_STAT *psbuf,int flags,mode_t mode, uint32 desired_access)
  92 {
  93         extern struct current_user current_user;
  94         pstring fname;
  95         int accmode = (flags & O_ACCMODE);
  96         int local_flags = flags;
  97
  98         fsp->fd = -1;
  99         fsp->oplock_type = NO_OPLOCK;
 100         errno = EPERM;
 101
 102         pstrcpy(fname,fname1);
 103
 104         /* Check permissions */
 105
 106         /*
 107          * This code was changed after seeing a client open request
 108          * containing the open mode of (DENY_WRITE/read-only) with
 109          * the 'create if not exist' bit set. The previous code
 110          * would fail to open the file read only on a read-only share
 111          * as it was checking the flags parameter  directly against O_RDONLY,
 112          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 113          * JRA.
 114          */
 115
 116         if (!CAN_WRITE(conn)) {
 117                 /* It's a read-only share - fail if we wanted to write. */
 118                 if(accmode != O_RDONLY) {
 119                         DEBUG(3,("Permission denied opening %s\n",fname));
 120                         check_for_pipe(fname);
 121                         return False;
 122                 } else if(flags & O_CREAT) {
 123                         /* We don't want to write - but we must make sure that O_CREAT
 124                            doesn't create the file if we have write access into the
 125                            directory.
 126                         */
 127                         flags &= ~O_CREAT;
 128                 }
 129         }
 130
 131         /*
 132          * This little piece of insanity is inspired by the
 133          * fact that an NT client can open a file for O_RDONLY,
 134          * but set the create disposition to FILE_EXISTS_TRUNCATE.
 135          * If the client *can* write to the file, then it expects to
 136          * truncate the file, even though it is opening for readonly.
 137          * Quicken uses this stupid trick in backup file creation...
 138          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
 139          * for helping track this one down. It didn't bite us in 2.0.x
 140          * as we always opened files read-write in that release. JRA.
 141          */
 142
 143         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
 144                 DEBUG(10,("open_file: truncate requested on read-only open for file %s\n",fname ));
 145                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
 146         }
 147
 148         if ((desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 149                         (local_flags & O_CREAT) || ((local_flags & O_TRUNC) == O_TRUNC) ) {
 150
 151                 /*
 152                  * We can't actually truncate here as the file may be locked.
 153                  * open_file_shared will take care of the truncate later. JRA.
 154                  */
 155
 156                 local_flags &= ~O_TRUNC;
 157
 158 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
 159                 /*
 160                  * We would block on opening a FIFO with no one else on the
 161                  * other end. Do what we used to do and add O_NONBLOCK to the
 162                  * open flags. JRA.
 163                  */
 164
 165                 if (VALID_STAT(*psbuf) && S_ISFIFO(psbuf->st_mode))
 166                         local_flags |= O_NONBLOCK;
 167 #endif
 168
 169                 /* Actually do the open */
 170                 fsp->fd = fd_open(conn, fname, local_flags, mode);
 171                 if (fsp->fd == -1)  {
 172                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
 173                                  fname,strerror(errno),local_flags,flags));
 174                         check_for_pipe(fname);
 175                         return False;
 176                 }
 177
 178                 /* Inherit the ACL if the file was created. */
 179                 if ((local_flags & O_CREAT) && !VALID_STAT(*psbuf))
 180                         inherit_access_acl(conn, fname, mode);
 181
 182         } else
 183                 fsp->fd = -1; /* What we used to call a stat open. */
 184
 185         if (!VALID_STAT(*psbuf)) {
 186                 int ret;
 187
 188                 if (fsp->fd == -1)
 189                         ret = VFS_STAT(conn, fname, psbuf);
 190                 else {
 191                         ret = VFS_FSTAT(fsp,fsp->fd,psbuf);
 192                         /* If we have an fd, this stat should succeed. */
 193                         if (ret == -1)
 194                                 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
 195                 }
 196
 197                 /* For a non-io open, this stat failing means file not found. JRA */
 198                 if (ret == -1) {
 199                         fd_close(conn, fsp);
 200                         return False;
 201                 }
 202         }
 203
 204         /*
 205          * POSIX allows read-only opens of directories. We don't
 206          * want to do this (we use a different code path for this)
 207          * so catch a directory open and return an EISDIR. JRA.
 208          */
 209
 210         if(S_ISDIR(psbuf->st_mode)) {
 211                 fd_close(conn, fsp);
 212                 errno = EISDIR;
 213                 return False;
 214         }
 215
 216         fsp->mode = psbuf->st_mode;
 217         fsp->inode = psbuf->st_ino;
 218         fsp->dev = psbuf->st_dev;
 219         fsp->vuid = current_user.vuid;
 220         fsp->size = psbuf->st_size;
 221         fsp->pos = -1;
 222         fsp->can_lock = True;
 223         fsp->can_read = ((flags & O_WRONLY)==0);
 224         fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
 225         fsp->share_mode = 0;
 226         fsp->desired_access = desired_access;
 227         fsp->print_file = False;
 228         fsp->modified = False;
 229         fsp->oplock_type = NO_OPLOCK;
 230         fsp->sent_oplock_break = NO_BREAK_SENT;
 231         fsp->is_directory = False;
 232         fsp->is_stat = False;
 233         fsp->directory_delete_on_close = False;
 234         string_set(&fsp->fsp_name,fname);
 235         fsp->wcp = NULL; /* Write cache pointer. */
 236
 237         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 238                  *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
 239                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 240                  conn->num_files_open + 1));
 241
 242         return True;
 243 }
 244
 245 /****************************************************************************
 246   C. Hoch 11/22/95
 247   Helper for open_file_shared.
 248   Truncate a file after checking locking; close file if locked.
 249   **************************************************************************/
 250
 251 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
 252 {
 253         SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
 254
 255         if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
 256                 errno = EACCES;
 257                 unix_ERR_class = ERRDOS;
 258                 unix_ERR_code = ERRlock;
 259                 unix_ERR_ntstatus = dos_to_ntstatus(ERRDOS, ERRlock);
 260                 return -1;
 261         } else {
 262                 return VFS_FTRUNCATE(fsp,fsp->fd,0);
 263         }
 264 }
 265
 266 /*******************************************************************
 267 return True if the filename is one of the special executable types
 268 ********************************************************************/
 269 static BOOL is_executable(const char *fname)
 270 {
 271         if ((fname = strrchr_m(fname,'.'))) {
 272                 if (strequal(fname,".com") ||
 273                     strequal(fname,".dll") ||
 274                     strequal(fname,".exe") ||
 275                     strequal(fname,".sym")) {
 276                         return True;
 277                 }
 278         }
 279         return False;
 280 }
 281
 282 enum {AFAIL,AREAD,AWRITE,AALL};
 283
 284 /*******************************************************************
 285 reproduce the share mode access table
 286 this is horrendoously complex, and really can't be justified on any
 287 rational grounds except that this is _exactly_ what NT does. See
 288 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
 289 test routines.
 290 ********************************************************************/
 291 static int access_table(int new_deny,int old_deny,int old_mode,
 292                         BOOL same_pid, BOOL isexe)
 293 {
 294           if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
 295
 296           if (same_pid) {
 297                   if (isexe && old_mode == DOS_OPEN_RDONLY &&
 298                       old_deny == DENY_DOS && new_deny == DENY_READ) {
 299                           return AFAIL;
 300                   }
 301                   if (!isexe && old_mode == DOS_OPEN_RDONLY &&
 302                       old_deny == DENY_DOS && new_deny == DENY_DOS) {
 303                           return AREAD;
 304                   }
 305                   if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
 306                           if (isexe) return AFAIL;
 307                           if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
 308                           return AALL;
 309                   }
 310                   if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
 311                           if (new_deny == DENY_FCB || new_deny == DENY_READ) {
 312                                   if (isexe) return AREAD;
 313                                   return AFAIL;
 314                           }
 315                   }
 316                   if (old_deny == DENY_FCB) {
 317                           if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
 318                           return AFAIL;
 319                   }
 320           }
 321
 322           if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
 323               old_deny == DENY_FCB || new_deny == DENY_FCB) {
 324                   if (isexe) {
 325                           if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
 326                                   return AFAIL;
 327                           }
 328                           if (old_deny == DENY_DOS) {
 329                                   if (new_deny == DENY_READ &&
 330                                       (old_mode == DOS_OPEN_RDONLY ||
 331                                        old_mode == DOS_OPEN_RDWR)) {
 332                                           return AFAIL;
 333                                   }
 334                                   if (new_deny == DENY_WRITE &&
 335                                       (old_mode == DOS_OPEN_WRONLY ||
 336                                        old_mode == DOS_OPEN_RDWR)) {
 337                                           return AFAIL;
 338                                   }
 339                                   return AALL;
 340                           }
 341                           if (old_deny == DENY_NONE) return AALL;
 342                           if (old_deny == DENY_READ) return AWRITE;
 343                           if (old_deny == DENY_WRITE) return AREAD;
 344                   }
 345                   /* it isn't a exe, dll, sym or com file */
 346                   if (old_deny == new_deny && same_pid)
 347                           return(AALL);
 348
 349                   if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
 350                   if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
 351
 352                   return(AFAIL);
 353           }
 354
 355           switch (new_deny)
 356                   {
 357                   case DENY_WRITE:
 358                           if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
 359                           if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
 360                           if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
 361                           return(AFAIL);
 362                   case DENY_READ:
 363                           if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
 364                           if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
 365                           if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
 366                           return(AFAIL);
 367                   case DENY_NONE:
 368                           if (old_deny==DENY_WRITE) return(AREAD);
 369                           if (old_deny==DENY_READ) return(AWRITE);
 370                           if (old_deny==DENY_NONE) return(AALL);
 371                           return(AFAIL);
 372                   }
 373           return(AFAIL);
 374 }
 375
 376
 377 /****************************************************************************
 378 check if we can open a file with a share mode
 379 ****************************************************************************/
 380
 381 static BOOL check_share_mode(connection_struct *conn, share_mode_entry *share, int share_mode, uint32 desired_access,
 382                              const char *fname, BOOL fcbopen, int *flags)
 383 {
 384         int deny_mode = GET_DENY_MODE(share_mode);
 385         int old_open_mode = GET_OPEN_MODE(share->share_mode);
 386         int old_deny_mode = GET_DENY_MODE(share->share_mode);
 387
 388         /*
 389          * share modes = false means don't bother to check for
 390          * DENY mode conflict. This is a *really* bad idea :-). JRA.
 391          */
 392
 393         if(!lp_share_modes(SNUM(conn)))
 394                 return True;
 395
 396         /*
 397          * Don't allow any opens once the delete on close flag has been
 398          * set.
 399          */
 400
 401         if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
 402                 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
 403                         fname ));
 404                 /* Use errno to map to correct error. */
 405                 unix_ERR_class = SMB_SUCCESS;
 406                 unix_ERR_code = 0;
 407                 unix_ERR_ntstatus = NT_STATUS_OK;
 408                 return False;
 409         }
 410
 411         /* this is a nasty hack, but necessary until we rewrite our open
 412            handling to use a NTCreateX call as the basic call.
 413            NT may open a file with neither read nor write access, and in
 414                    this case it expects the open not to conflict with any
 415                    existing deny modes. This happens (for example) during a
 416                    "xcopy /o" where the second file descriptor is used for
 417                    ACL sets
 418                    (tridge)
 419         */
 420
 421         /*
 422          * This is a bit wierd - the test for desired access not having the
 423          * critical bits seems seems odd. Firstly, if both opens have no
 424          * critical bits then always ignore. Then check the "allow delete"
 425          * then check for either. This probably isn't quite right yet but
 426          * gets us much closer. JRA.
 427          */
 428
 429         /*
 430          * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
 431          * and the existing desired_acces then share modes don't conflict.
 432          */
 433
 434         if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) &&
 435                 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
 436
 437                 /*
 438                  * Wrinkle discovered by smbtorture....
 439                  * If both are non-io open and requester is asking for delete and current open has delete access
 440                  * but neither open has allowed file share delete then deny.... this is very strange and
 441                  * seems to be the only case in which non-io opens conflict. JRA.
 442                  */
 443
 444                 if ((desired_access & DELETE_ACCESS) && (share->desired_access & DELETE_ACCESS) &&
 445                                 (!GET_ALLOW_SHARE_DELETE(share->share_mode) || !GET_ALLOW_SHARE_DELETE(share_mode))) {
 446                         DEBUG(5,("check_share_mode: Failing open on file %s as delete access requests conflict.\n",
 447                                 fname ));
 448                         unix_ERR_class = ERRDOS;
 449                         unix_ERR_code = ERRbadshare;
 450                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 451
 452                         return False;
 453                 }
 454
 455                 DEBUG(5,("check_share_mode: Allowing open on file %s as both desired access (0x%x) \
 456 and existing desired access (0x%x) are non-data opens\n",
 457                         fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
 458                 return True;
 459         }
 460
 461         /*
 462          * If delete access was requested and the existing share mode doesn't have
 463          * ALLOW_SHARE_DELETE then deny.
 464          */
 465
 466         if ((desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
 467                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
 468                         fname ));
 469                 unix_ERR_class = ERRDOS;
 470                 unix_ERR_code = ERRbadshare;
 471                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 472
 473                 return False;
 474         }
 475
 476         /*
 477          * The inverse of the above.
 478          * If delete access was granted and the new share mode doesn't have
 479          * ALLOW_SHARE_DELETE then deny.
 480          */
 481
 482         if ((share->desired_access & DELETE_ACCESS) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
 483                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
 484                         fname ));
 485                 unix_ERR_class = ERRDOS;
 486                 unix_ERR_code = ERRbadshare;
 487                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 488
 489                 return False;
 490         }
 491
 492         /*
 493          * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
 494          * then share modes don't conflict. Likewise with existing desired access.
 495          */
 496
 497         if ( !(desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
 498                 !(share->desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ) {
 499                 DEBUG(5,("check_share_mode: Allowing open on file %s as desired access (0x%x) doesn't conflict with\
 500 existing desired access (0x%x).\n", fname, (unsigned int)desired_access, (unsigned int)share->desired_access ));
 501                 return True;
 502         }
 503
 504         {
 505                 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
 506                                                 (share->pid == sys_getpid()),is_executable(fname));
 507
 508                 if ((access_allowed == AFAIL) ||
 509                         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
 510                         (access_allowed == AREAD && *flags != O_RDONLY) ||
 511                         (access_allowed == AWRITE && *flags != O_WRONLY)) {
 512
 513                         DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
 514                                 deny_mode,old_deny_mode,old_open_mode,
 515                                 (int)share->pid,fname, fcbopen, *flags, access_allowed));
 516
 517                         unix_ERR_class = ERRDOS;
 518                         unix_ERR_code = ERRbadshare;
 519                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 520
 521                         return False;
 522                 }
 523
 524                 if (access_allowed == AREAD)
 525                         *flags = O_RDONLY;
 526
 527                 if (access_allowed == AWRITE)
 528                         *flags = O_WRONLY;
 529
 530         }
 531
 532         return True;
 533 }
 534
 535
 536 #if defined(DEVELOPER)
 537 static void validate_my_share_entries(share_mode_entry *share_entry)
 538 {
 539         files_struct *fsp;
 540
 541         if (share_entry->pid != sys_getpid())
 542                 return;
 543
 544         fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id);
 545         if (!fsp) {
 546                 smb_panic("validate_my_share_entries: Cannot match a share entry with an open file\n");
 547         }
 548
 549         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
 550                 pstring str;
 551                 slprintf(str, sizeof(str)-1, "validate_my_share_entries: file %s, oplock_type = 0x%x, op_type = 0x%x\n",
 552                                 fsp->fsp_name, (unsigned int)fsp->oplock_type, (unsigned int)share_entry->op_type );
 553                 smb_panic(str);
 554         }
 555 }
 556 #endif
 557
 558 /****************************************************************************
 559  Deal with open deny mode and oplock break processing.
 560  Invarient: Share mode must be locked on entry and exit.
 561  Returns -1 on error, or number of share modes on success (may be zero).
 562 ****************************************************************************/
 563
 564 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
 565                            SMB_INO_T inode,
 566                            uint32 desired_access,
 567                            int share_mode, int *p_flags, int *p_oplock_request,
 568                            BOOL *p_all_current_opens_are_level_II)
 569 {
 570         int i;
 571         int num_share_modes;
 572         int oplock_contention_count = 0;
 573         share_mode_entry *old_shares = 0;
 574         BOOL fcbopen = False;
 575         BOOL broke_oplock;
 576
 577         if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
 578                 fcbopen = True;
 579
 580         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 581
 582         if(num_share_modes == 0)
 583                 return 0;
 584
 585         /*
 586          * Check if the share modes will give us access.
 587          */
 588
 589         do {
 590                 share_mode_entry broken_entry;
 591
 592                 broke_oplock = False;
 593                 *p_all_current_opens_are_level_II = True;
 594
 595                 for(i = 0; i < num_share_modes; i++) {
 596                         share_mode_entry *share_entry = &old_shares[i];
 597
 598 #if defined(DEVELOPER)
 599                         validate_my_share_entries(share_entry);
 600 #endif
 601
 602                         /*
 603                          * By observation of NetBench, oplocks are broken *before* share
 604                          * modes are checked. This allows a file to be closed by the client
 605                          * if the share mode would deny access and the client has an oplock.
 606                          * Check if someone has an oplock on this file. If so we must break
 607                          * it before continuing.
 608                          */
 609
 610                         if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 611                            (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
 612
 613                                 BOOL opb_ret;
 614
 615                                 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
 616 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 617
 618                                 /* Oplock break - unlock to request it. */
 619                                 unlock_share_entry(conn, dev, inode);
 620
 621                                 opb_ret = request_oplock_break(share_entry, False);
 622
 623                                 /* Now relock. */
 624                                 lock_share_entry(conn, dev, inode);
 625
 626                                 if(opb_ret == False) {
 627                                         DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
 628 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 629                                         SAFE_FREE(old_shares);
 630                                         errno = EACCES;
 631                                         unix_ERR_class = ERRDOS;
 632                                         unix_ERR_code = ERRbadshare;
 633                                         unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 634                                         return -1;
 635                                 }
 636
 637                                 broke_oplock = True;
 638                                 broken_entry = *share_entry;
 639                                 break;
 640
 641                         } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 642                                 *p_all_current_opens_are_level_II = False;
 643                         }
 644
 645                         /* someone else has a share lock on it, check to see if we can too */
 646                         if (!check_share_mode(conn, share_entry, share_mode, desired_access,
 647                                                 fname, fcbopen, p_flags)) {
 648                                 SAFE_FREE(old_shares);
 649                                 errno = EACCES;
 650                                 return -1;
 651                         }
 652
 653                 } /* end for */
 654
 655                 if(broke_oplock) {
 656                         SAFE_FREE(old_shares);
 657                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 658                         oplock_contention_count++;
 659
 660                         /* Paranoia check that this is no longer an exlusive entry. */
 661                         for(i = 0; i < num_share_modes; i++) {
 662                                 share_mode_entry *share_entry = &old_shares[i];
 663
 664                                 if (share_modes_identical(&broken_entry, share_entry) &&
 665                                     EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
 666
 667                                         /*
 668                                          * This should not happen. The target left this oplock
 669                                          * as exlusive.... The process *must* be dead....
 670                                          */
 671
 672                                         DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
 673 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
 674
 675                                         if (process_exists(broken_entry.pid)) {
 676                                                 DEBUG(0,("open_mode_check: Existent process %d left active oplock.\n",
 677                                                          broken_entry.pid ));
 678                                         }
 679
 680                                         if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
 681                                                 errno = EACCES;
 682                                                 unix_ERR_class = ERRDOS;
 683                                                 unix_ERR_code = ERRbadshare;
 684                                                 unix_ERR_ntstatus = NT_STATUS_SHARING_VIOLATION;
 685                                                 return -1;
 686                                         }
 687
 688                                         /*
 689                                          * We must reload the share modes after deleting the
 690                                          * other process's entry.
 691                                          */
 692
 693                                         SAFE_FREE(old_shares);
 694                                         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 695                                         break;
 696                                 }
 697                         } /* end for paranoia... */
 698                 } /* end if broke_oplock */
 699
 700         } while(broke_oplock);
 701
 702         if(old_shares != 0)
 703                 SAFE_FREE(old_shares);
 704
 705         /*
 706          * Refuse to grant an oplock in case the contention limit is
 707          * reached when going through the lock list multiple times.
 708          */
 709
 710         if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
 711                 *p_oplock_request = 0;
 712                 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
 713                          oplock_contention_count ));
 714         }
 715
 716         return num_share_modes;
 717 }
 718
 719 /****************************************************************************
 720 set a kernel flock on a file for NFS interoperability
 721 this requires a patch to Linux
 722 ****************************************************************************/
 723 static void kernel_flock(files_struct *fsp, int deny_mode)
 724 {
 725 #if HAVE_KERNEL_SHARE_MODES
 726         int kernel_mode = 0;
 727         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 728         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 729         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 730         if (kernel_mode) flock(fsp->fd, kernel_mode);
 731 #endif
 732         ;;
 733 }
 734
 735
 736 static BOOL open_match_attributes(connection_struct *conn, char *path, mode_t existing_mode,
 737                 mode_t new_mode, mode_t *returned_mode)
 738 {
 739         uint32 old_dos_mode, new_dos_mode;
 740         uint32 noarch_old_dos_mode, noarch_new_dos_mode;
 741         SMB_STRUCT_STAT sbuf;
 742
 743         ZERO_STRUCT(sbuf);
 744
 745         sbuf.st_mode = existing_mode;
 746         old_dos_mode = dos_mode(conn, path, &sbuf);
 747
 748         sbuf.st_mode = new_mode;
 749         new_dos_mode = dos_mode(conn, path, &sbuf);
 750
 751         noarch_old_dos_mode = (old_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 752         noarch_new_dos_mode = (new_dos_mode & ~FILE_ATTRIBUTE_ARCHIVE);
 753
 754         if((noarch_old_dos_mode == 0 && noarch_new_dos_mode != 0) ||
 755            (noarch_old_dos_mode != 0 && ((noarch_old_dos_mode & noarch_new_dos_mode) == noarch_old_dos_mode)))
 756                 *returned_mode = new_mode;
 757         else
 758                 *returned_mode = (mode_t)0;
 759
 760         DEBUG(10,("open_match_attributes: file %s old_dos_mode = 0x%x, existing_mode = 0%o, new_dos_mode = 0x%x returned_mode = 0%o\n",
 761                 path,
 762                 old_dos_mode, (unsigned int)existing_mode, new_dos_mode, (unsigned int)*returned_mode ));
 763
 764         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 765         if (lp_map_system(SNUM(conn))) {
 766                 if ((old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && !(new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
 767                         return False;
 768         }
 769         if (lp_map_hidden(SNUM(conn))) {
 770                 if ((old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && !(new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
 771                         return False;
 772         }
 773         return True;
 774 }
 775
 776 /****************************************************************************
 777  Open a file with a share mode.
 778 ****************************************************************************/
 779
 780 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 781                                int share_mode,int ofun, mode_t mode,int oplock_request,
 782                                int *Access,int *action)
 783 {
 784         return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, mode,
 785                                  oplock_request, Access, action);
 786 }
 787
 788 /****************************************************************************
 789  Open a file with a share mode.
 790 ****************************************************************************/
 791
 792 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 793                                 uint32 desired_access,
 794                                 int share_mode,int ofun, mode_t mode,int oplock_request,
 795                                 int *Access,int *action)
 796 {
 797         int flags=0;
 798         int flags2=0;
 799         int deny_mode = GET_DENY_MODE(share_mode);
 800         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 801         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
 802         BOOL file_existed = VALID_STAT(*psbuf);
 803         BOOL fcbopen = False;
 804         BOOL def_acl = False;
 805         SMB_DEV_T dev = 0;
 806         SMB_INO_T inode = 0;
 807         int num_share_modes = 0;
 808         BOOL all_current_opens_are_level_II = False;
 809         BOOL fsp_open = False;
 810         files_struct *fsp = NULL;
 811         int open_mode=0;
 812         uint16 port = 0;
 813         mode_t new_mode = (mode_t)0;
 814
 815         if (conn->printer) {
 816                 /* printers are handled completely differently. Most of the passed parameters are
 817                         ignored */
 818                 if (Access)
 819                         *Access = DOS_OPEN_WRONLY;
 820                 if (action)
 821                         *action = FILE_WAS_CREATED;
 822                 return print_fsp_open(conn, fname);
 823         }
 824
 825         fsp = file_new(conn);
 826         if(!fsp)
 827                 return NULL;
 828
 829         DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 830                 fname, share_mode, ofun, (int)mode,  oplock_request ));
 831
 832         if (!check_name(fname,conn)) {
 833                 file_free(fsp);
 834                 return NULL;
 835         }
 836
 837         /* ignore any oplock requests if oplocks are disabled */
 838         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 839                 oplock_request = 0;
 840         }
 841
 842         /* this is for OS/2 EAs - try and say we don't support them */
 843         if (strstr(fname,".+,;=[].")) {
 844                 unix_ERR_class = ERRDOS;
 845                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 846 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 847                 unix_ERR_code = ERRcannotopen;
 848 #else /* OS2_WPS_FIX */
 849                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 850 #endif /* OS2_WPS_FIX */
 851
 852                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 853                 file_free(fsp);
 854                 return NULL;
 855         }
 856
 857         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 858                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 859                         fname ));
 860                 file_free(fsp);
 861                 errno = EEXIST;
 862                 return NULL;
 863         }
 864
 865         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
 866                 flags2 |= O_CREAT;
 867
 868         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
 869                 flags2 |= O_TRUNC;
 870
 871         /* We only care about matching attributes on file exists and truncate. */
 872         if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
 873                 if (!open_match_attributes(conn, fname, psbuf->st_mode, mode, &new_mode)) {
 874                         DEBUG(5,("open_file_shared: attributes missmatch for file %s (0%o, 0%o)\n",
 875                                                 fname, psbuf->st_mode, mode ));
 876                         file_free(fsp);
 877                         errno = EACCES;
 878                         return NULL;
 879                 }
 880         }
 881
 882         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 883                 flags2 |= O_EXCL;
 884
 885         /* note that we ignore the append flag as
 886                 append does not mean the same thing under dos and unix */
 887
 888         switch (GET_OPEN_MODE(share_mode)) {
 889                 case DOS_OPEN_WRONLY:
 890                         flags = O_WRONLY;
 891                         if (desired_access == 0)
 892                                 desired_access = FILE_WRITE_DATA;
 893                         break;
 894                 case DOS_OPEN_FCB:
 895                         fcbopen = True;
 896                         flags = O_RDWR;
 897                         if (desired_access == 0)
 898                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 899                         break;
 900                 case DOS_OPEN_RDWR:
 901                         flags = O_RDWR;
 902                         if (desired_access == 0)
 903                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 904                         break;
 905                 default:
 906                         flags = O_RDONLY;
 907                         if (desired_access == 0)
 908                                 desired_access = FILE_READ_DATA;
 909                         break;
 910         }
 911
 912 #if defined(O_SYNC)
 913         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 914                 flags2 |= O_SYNC;
 915         }
 916 #endif /* O_SYNC */
 917
 918         if (flags != O_RDONLY && file_existed &&
 919                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 920                 if (!fcbopen) {
 921                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 922                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 923                         file_free(fsp);
 924                         errno = EACCES;
 925                         return NULL;
 926                 }
 927                 flags = O_RDONLY;
 928         }
 929
 930         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 931                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 932                 file_free(fsp);
 933                 errno = EINVAL;
 934                 return NULL;
 935         }
 936
 937         if (file_existed) {
 938
 939                 dev = psbuf->st_dev;
 940                 inode = psbuf->st_ino;
 941
 942                 lock_share_entry(conn, dev, inode);
 943
 944                 num_share_modes = open_mode_check(conn, fname, dev, inode,
 945                                                   desired_access,
 946                                                   share_mode,
 947                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
 948                 if(num_share_modes == -1) {
 949
 950                         /*
 951                          * This next line is a subtlety we need for MS-Access. If a file open will
 952                          * fail due to share permissions and also for security (access)
 953                          * reasons, we need to return the access failed error, not the
 954                          * share error. This means we must attempt to open the file anyway
 955                          * in order to get the UNIX access error - even if we're going to
 956                          * fail the open for share reasons. This is bad, as we're burning
 957                          * another fd if there are existing locks but there's nothing else
 958                          * we can do. We also ensure we're not going to create or tuncate
 959                          * the file as we only want an access decision at this stage. JRA.
 960                          */
 961                         errno = 0;
 962                         fsp_open = open_file(fsp,conn,fname,psbuf,
 963                                                 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
 964
 965                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 966 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 967                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 968
 969                         if (!fsp_open && errno) {
 970                                 unix_ERR_class = ERRDOS;
 971                                 unix_ERR_code = ERRnoaccess;
 972                                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
 973                         }
 974
 975                         unlock_share_entry(conn, dev, inode);
 976                         if (fsp_open)
 977                                 fd_close(conn, fsp);
 978                         file_free(fsp);
 979                         return NULL;
 980                 }
 981
 982                 /*
 983                  * We exit this block with the share entry *locked*.....
 984                  */
 985         }
 986
 987         /*
 988          * Ensure we pay attention to default ACLs on directories if required.
 989          */
 990
 991         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
 992                         (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
 993                 mode = 0777;
 994
 995         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 996                         flags,flags2,(int)mode));
 997
 998         /*
 999          * open_file strips any O_TRUNC flags itself.
1000          */
1001
1002         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
1003
1004         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
1005                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
1006                         flags = O_RDONLY;
1007         }
1008
1009         if (!fsp_open) {
1010                 if(file_existed)
1011                         unlock_share_entry(conn, dev, inode);
1012                 file_free(fsp);
1013                 return NULL;
1014         }
1015
1016         /*
1017          * Deal with the race condition where two smbd's detect the file doesn't
1018          * exist and do the create at the same time. One of them will win and
1019          * set a share mode, the other (ie. this one) should check if the
1020          * requested share mode for this create is allowed.
1021          */
1022
1023         if (!file_existed) {
1024
1025                 lock_share_entry_fsp(fsp);
1026
1027                 num_share_modes = open_mode_check(conn, fname, dev, inode,
1028                                                   desired_access,
1029                                                   share_mode,
1030                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
1031
1032                 if(num_share_modes == -1) {
1033                         unlock_share_entry_fsp(fsp);
1034                         fd_close(conn,fsp);
1035                         file_free(fsp);
1036                         return NULL;
1037                 }
1038
1039                 /*
1040                  * If there are any share modes set then the file *did*
1041                  * exist. Ensure we return the correct value for action.
1042                  */
1043
1044                 if (num_share_modes > 0)
1045                         file_existed = True;
1046
1047                 /*
1048                  * We exit this block with the share entry *locked*.....
1049                  */
1050         }
1051
1052         /* note that we ignore failure for the following. It is
1053            basically a hack for NFS, and NFS will never set one of
1054            these only read them. Nobody but Samba can ever set a deny
1055            mode and we have already checked our more authoritative
1056            locking database for permission to set this deny mode. If
1057            the kernel refuses the operations then the kernel is wrong */
1058         kernel_flock(fsp, deny_mode);
1059
1060         /*
1061          * At this point onwards, we can guarentee that the share entry
1062          * is locked, whether we created the file or not, and that the
1063          * deny mode is compatible with all current opens.
1064          */
1065
1066         /*
1067          * If requested, truncate the file.
1068          */
1069
1070         if (flags2&O_TRUNC) {
1071                 /*
1072                  * We are modifing the file after open - update the stat struct..
1073                  */
1074                 if ((truncate_unless_locked(conn,fsp) == -1) || (VFS_FSTAT(fsp,fsp->fd,psbuf)==-1)) {
1075                         unlock_share_entry_fsp(fsp);
1076                         fd_close(conn,fsp);
1077                         file_free(fsp);
1078                         return NULL;
1079                 }
1080         }
1081
1082         switch (flags) {
1083                 case O_RDONLY:
1084                         open_mode = DOS_OPEN_RDONLY;
1085                         break;
1086                 case O_RDWR:
1087                         open_mode = DOS_OPEN_RDWR;
1088                         break;
1089                 case O_WRONLY:
1090                         open_mode = DOS_OPEN_WRONLY;
1091                         break;
1092         }
1093
1094         fsp->share_mode = SET_DENY_MODE(deny_mode) |
1095                                                 SET_OPEN_MODE(open_mode) |
1096                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1097
1098         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1099
1100         if (Access)
1101                 (*Access) = open_mode;
1102
1103         if (action) {
1104                 if (file_existed && !(flags2 & O_TRUNC))
1105                         *action = FILE_WAS_OPENED;
1106                 if (!file_existed)
1107                         *action = FILE_WAS_CREATED;
1108                 if (file_existed && (flags2 & O_TRUNC))
1109                         *action = FILE_WAS_OVERWRITTEN;
1110         }
1111
1112         /*
1113          * Setup the oplock info in both the shared memory and
1114          * file structs.
1115          */
1116
1117         if(oplock_request && (num_share_modes == 0) &&
1118                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1119                 port = global_oplock_port;
1120         } else if (oplock_request && all_current_opens_are_level_II) {
1121                 port = global_oplock_port;
1122                 oplock_request = LEVEL_II_OPLOCK;
1123                 set_file_oplock(fsp, oplock_request);
1124         } else {
1125                 port = 0;
1126                 oplock_request = 0;
1127         }
1128
1129         set_share_mode(fsp, port, oplock_request);
1130
1131         if (delete_on_close) {
1132                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1133
1134                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1135                         /* Remember to delete the mode we just added. */
1136                         del_share_mode(fsp, NULL);
1137                         unlock_share_entry_fsp(fsp);
1138                         fd_close(conn,fsp);
1139                         file_free(fsp);
1140                         return NULL;
1141                 }
1142         }
1143
1144         /*
1145          * Take care of inherited ACLs on created files - if default ACL not
1146          * selected.
1147          */
1148
1149         if (!file_existed && !def_acl) {
1150
1151                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1152
1153                 if (VFS_FCHMOD_ACL(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1154                         errno = saved_errno; /* Ignore ENOSYS */
1155
1156         } else if (new_mode) {
1157
1158                 int ret = -1;
1159
1160                 /* Attributes need changing. File already existed. */
1161
1162                 {
1163                         int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1164                         ret = VFS_FCHMOD_ACL(fsp, fsp->fd, new_mode);
1165
1166                         if (ret == -1 && errno == ENOSYS) {
1167                                 errno = saved_errno; /* Ignore ENOSYS */
1168                         } else {
1169                                 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1170                                         fname, (int)new_mode));
1171                                 ret = 0; /* Don't do the fchmod below. */
1172                         }
1173                 }
1174
1175                 if ((ret == -1) && (VFS_FCHMOD(fsp, fsp->fd, new_mode) == -1))
1176                         DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1177                                 fname, (int)new_mode));
1178         }
1179
1180         unlock_share_entry_fsp(fsp);
1181
1182         conn->num_files_open++;
1183
1184         return fsp;
1185 }
1186
1187 /****************************************************************************
1188  Open a file for for write to ensure that we can fchmod it.
1189 ****************************************************************************/
1190
1191 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1192 {
1193         files_struct *fsp = NULL;
1194         BOOL fsp_open;
1195
1196         if (!VALID_STAT(*psbuf))
1197                 return NULL;
1198
1199         fsp = file_new(conn);
1200         if(!fsp)
1201                 return NULL;
1202
1203         /* note! we must use a non-zero desired access or we don't get
1204            a real file descriptor. Oh what a twisted web we weave. */
1205         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1206
1207         /*
1208          * This is not a user visible file open.
1209          * Don't set a share mode and don't increment
1210          * the conn->num_files_open.
1211          */
1212
1213         if (!fsp_open) {
1214                 file_free(fsp);
1215                 return NULL;
1216         }
1217
1218         return fsp;
1219 }
1220
1221 /****************************************************************************
1222  Close the fchmod file fd - ensure no locks are lost.
1223 ****************************************************************************/
1224
1225 int close_file_fchmod(files_struct *fsp)
1226 {
1227         int ret = fd_close(fsp->conn, fsp);
1228         file_free(fsp);
1229         return ret;
1230 }
1231
1232 /****************************************************************************
1233  Open a directory from an NT SMB call.
1234 ****************************************************************************/
1235
1236 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1237                         uint32 desired_access, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1238 {
1239         extern struct current_user current_user;
1240         BOOL got_stat = False;
1241         files_struct *fsp = file_new(conn);
1242         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1243
1244         if(!fsp)
1245                 return NULL;
1246
1247         if (VALID_STAT(*psbuf))
1248                 got_stat = True;
1249
1250         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1251                 file_free(fsp);
1252                 errno = EEXIST; /* Setup so correct error is returned to client. */
1253                 return NULL;
1254         }
1255
1256         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1257
1258                 if (got_stat) {
1259
1260                         if(!S_ISDIR(psbuf->st_mode)) {
1261                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1262                                 file_free(fsp);
1263                                 errno = EACCES;
1264                                 return NULL;
1265                         }
1266                         *action = FILE_WAS_OPENED;
1267
1268                 } else {
1269
1270                         /*
1271                          * Try and create the directory.
1272                          */
1273
1274                         if(!CAN_WRITE(conn)) {
1275                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1276                                 file_free(fsp);
1277                                 errno = EACCES;
1278                                 return NULL;
1279                         }
1280
1281                         if(vfs_MkDir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1282                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1283                                          fname, strerror(errno) ));
1284                                 file_free(fsp);
1285                                 return NULL;
1286                         }
1287
1288                         if(VFS_STAT(conn,fname, psbuf) != 0) {
1289                                 file_free(fsp);
1290                                 return NULL;
1291                         }
1292
1293                         *action = FILE_WAS_CREATED;
1294
1295                 }
1296         } else {
1297
1298                 /*
1299                  * Don't create - just check that it *was* a directory.
1300                  */
1301
1302                 if(!got_stat) {
1303                         DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1304                                  fname, strerror(errno) ));
1305                         file_free(fsp);
1306                         return NULL;
1307                 }
1308
1309                 if(!S_ISDIR(psbuf->st_mode)) {
1310                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1311                         file_free(fsp);
1312                         return NULL;
1313                 }
1314
1315                 *action = FILE_WAS_OPENED;
1316         }
1317
1318         DEBUG(5,("open_directory: opening directory %s\n", fname));
1319
1320         /*
1321          * Setup the files_struct for it.
1322          */
1323
1324         fsp->mode = psbuf->st_mode;
1325         fsp->inode = psbuf->st_ino;
1326         fsp->dev = psbuf->st_dev;
1327         fsp->size = psbuf->st_size;
1328         fsp->vuid = current_user.vuid;
1329         fsp->pos = -1;
1330         fsp->can_lock = True;
1331         fsp->can_read = False;
1332         fsp->can_write = False;
1333         fsp->share_mode = share_mode;
1334         fsp->desired_access = desired_access;
1335         fsp->print_file = False;
1336         fsp->modified = False;
1337         fsp->oplock_type = NO_OPLOCK;
1338         fsp->sent_oplock_break = NO_BREAK_SENT;
1339         fsp->is_directory = True;
1340         fsp->is_stat = False;
1341         fsp->directory_delete_on_close = False;
1342         string_set(&fsp->fsp_name,fname);
1343
1344         if (delete_on_close) {
1345                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1346
1347                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1348                         file_free(fsp);
1349                         return NULL;
1350                 }
1351         }
1352         conn->num_files_open++;
1353
1354         return fsp;
1355 }
1356
1357 /****************************************************************************
1358  Open a pseudo-file (no locking checks - a 'stat' open).
1359 ****************************************************************************/
1360
1361 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1362 {
1363         extern struct current_user current_user;
1364         files_struct *fsp = NULL;
1365
1366         if (!VALID_STAT(*psbuf))
1367                 return NULL;
1368
1369         /* Can't 'stat' open directories. */
1370         if(S_ISDIR(psbuf->st_mode))
1371                 return NULL;
1372
1373         fsp = file_new(conn);
1374         if(!fsp)
1375                 return NULL;
1376
1377         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1378
1379         /*
1380          * Setup the files_struct for it.
1381          */
1382
1383         fsp->mode = psbuf->st_mode;
1384         /*
1385          * Don't store dev or inode, we don't want any iterator
1386          * to see this.
1387          */
1388         fsp->inode = (SMB_INO_T)0;
1389         fsp->dev = (SMB_DEV_T)0;
1390         fsp->size = psbuf->st_size;
1391         fsp->vuid = current_user.vuid;
1392         fsp->pos = -1;
1393         fsp->can_lock = False;
1394         fsp->can_read = False;
1395         fsp->can_write = False;
1396         fsp->share_mode = 0;
1397         fsp->desired_access = 0;
1398         fsp->print_file = False;
1399         fsp->modified = False;
1400         fsp->oplock_type = NO_OPLOCK;
1401         fsp->sent_oplock_break = NO_BREAK_SENT;
1402         fsp->is_directory = False;
1403         fsp->is_stat = True;
1404         fsp->directory_delete_on_close = False;
1405         string_set(&fsp->fsp_name,fname);
1406
1407         conn->num_files_open++;
1408
1409         return fsp;
1410 }