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