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