source/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);
 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, mode_t new_mode)
 702 {
 703         uint32 old_dos_mode, new_dos_mode;
 704         SMB_STRUCT_STAT sbuf;
 705
 706         ZERO_STRUCT(sbuf);
 707
 708         sbuf.st_mode = existing_mode;
 709         old_dos_mode = dos_mode(conn, path, &sbuf);
 710
 711         sbuf.st_mode = new_mode;
 712         new_dos_mode = dos_mode(conn, path, &sbuf);
 713
 714         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
 715         if (lp_map_system(SNUM(conn))) {
 716                 if ((old_dos_mode & FILE_ATTRIBUTE_SYSTEM) && !(new_dos_mode & FILE_ATTRIBUTE_SYSTEM))
 717                         return False;
 718         }
 719         if (lp_map_hidden(SNUM(conn))) {
 720                 if ((old_dos_mode & FILE_ATTRIBUTE_HIDDEN) && !(new_dos_mode & FILE_ATTRIBUTE_HIDDEN))
 721                         return False;
 722         }
 723         return True;
 724 }
 725
 726 /****************************************************************************
 727  Open a file with a share mode. On output from this open we are guarenteeing
 728  that
 729 ****************************************************************************/
 730 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 731                                int share_mode,int ofun, mode_t mode,int oplock_request,
 732                                int *Access,int *action)
 733 {
 734         return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, mode,
 735                                  oplock_request, Access, action);
 736 }
 737
 738 /****************************************************************************
 739  Open a file with a share mode. On output from this open we are guarenteeing
 740  that
 741 ****************************************************************************/
 742 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 743                                 uint32 desired_access,
 744                                 int share_mode,int ofun, mode_t mode,int oplock_request,
 745                                 int *Access,int *action)
 746 {
 747         int flags=0;
 748         int flags2=0;
 749         int deny_mode = GET_DENY_MODE(share_mode);
 750         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 751         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
 752         BOOL file_existed = VALID_STAT(*psbuf);
 753         BOOL fcbopen = False;
 754         BOOL def_acl = False;
 755         SMB_DEV_T dev = 0;
 756         SMB_INO_T inode = 0;
 757         int num_share_modes = 0;
 758         BOOL all_current_opens_are_level_II = False;
 759         BOOL fsp_open = False;
 760         files_struct *fsp = NULL;
 761         int open_mode=0;
 762         uint16 port = 0;
 763
 764         if (conn->printer) {
 765                 /* printers are handled completely differently. Most of the passed parameters are
 766                         ignored */
 767                 if (Access)
 768                         *Access = DOS_OPEN_WRONLY;
 769                 if (action)
 770                         *action = FILE_WAS_CREATED;
 771                 return print_fsp_open(conn, fname);
 772         }
 773
 774         fsp = file_new(conn);
 775         if(!fsp)
 776                 return NULL;
 777
 778         DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 779                 fname, share_mode, ofun, (int)mode,  oplock_request ));
 780
 781         if (!check_name(fname,conn)) {
 782                 file_free(fsp);
 783                 return NULL;
 784         }
 785
 786         /* ignore any oplock requests if oplocks are disabled */
 787         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 788                 oplock_request = 0;
 789         }
 790
 791         /* this is for OS/2 EAs - try and say we don't support them */
 792         if (strstr(fname,".+,;=[].")) {
 793                 unix_ERR_class = ERRDOS;
 794                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 795 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 796                 unix_ERR_code = ERRcannotopen;
 797 #else /* OS2_WPS_FIX */
 798                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 799 #endif /* OS2_WPS_FIX */
 800
 801                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 802                 file_free(fsp);
 803                 return NULL;
 804         }
 805
 806         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 807                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 808                         fname ));
 809                 file_free(fsp);
 810                 errno = EEXIST;
 811                 return NULL;
 812         }
 813
 814         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
 815                 flags2 |= O_CREAT;
 816
 817         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
 818                 flags2 |= O_TRUNC;
 819
 820         /* We only care about matching attributes on file exists and truncate. */
 821         if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
 822                 if (!open_match_attributes(conn, fname, psbuf->st_mode, mode)) {
 823                         DEBUG(5,("open_file_shared: attributes missmatch for file %s (0%o, 0%o)\n",
 824                                                 fname, psbuf->st_mode, mode ));
 825                         file_free(fsp);
 826                         errno = EACCES;
 827                         return NULL;
 828                 }
 829         }
 830
 831         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 832                 flags2 |= O_EXCL;
 833
 834         /* note that we ignore the append flag as
 835                 append does not mean the same thing under dos and unix */
 836
 837         switch (GET_OPEN_MODE(share_mode)) {
 838                 case DOS_OPEN_WRONLY:
 839                         flags = O_WRONLY;
 840                         if (desired_access == 0)
 841                                 desired_access = FILE_WRITE_DATA;
 842                         break;
 843                 case DOS_OPEN_FCB:
 844                         fcbopen = True;
 845                         flags = O_RDWR;
 846                         if (desired_access == 0)
 847                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 848                         break;
 849                 case DOS_OPEN_RDWR:
 850                         flags = O_RDWR;
 851                         if (desired_access == 0)
 852                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 853                         break;
 854                 default:
 855                         flags = O_RDONLY;
 856                         if (desired_access == 0)
 857                                 desired_access = FILE_READ_DATA;
 858                         break;
 859         }
 860
 861 #if defined(O_SYNC)
 862         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 863                 flags2 |= O_SYNC;
 864         }
 865 #endif /* O_SYNC */
 866
 867         if (flags != O_RDONLY && file_existed &&
 868                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 869                 if (!fcbopen) {
 870                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 871                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 872                         file_free(fsp);
 873                         errno = EACCES;
 874                         return NULL;
 875                 }
 876                 flags = O_RDONLY;
 877         }
 878
 879         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 880                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 881                 file_free(fsp);
 882                 errno = EINVAL;
 883                 return NULL;
 884         }
 885
 886         if (file_existed) {
 887
 888                 dev = psbuf->st_dev;
 889                 inode = psbuf->st_ino;
 890
 891                 lock_share_entry(conn, dev, inode);
 892
 893                 num_share_modes = open_mode_check(conn, fname, dev, inode,
 894                                                   desired_access,
 895                                                   share_mode,
 896                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
 897                 if(num_share_modes == -1) {
 898
 899                         /*
 900                          * This next line is a subtlety we need for MS-Access. If a file open will
 901                          * fail due to share permissions and also for security (access)
 902                          * reasons, we need to return the access failed error, not the
 903                          * share error. This means we must attempt to open the file anyway
 904                          * in order to get the UNIX access error - even if we're going to
 905                          * fail the open for share reasons. This is bad, as we're burning
 906                          * another fd if there are existing locks but there's nothing else
 907                          * we can do. We also ensure we're not going to create or tuncate
 908                          * the file as we only want an access decision at this stage. JRA.
 909                          */
 910                         fsp_open = open_file(fsp,conn,fname,psbuf,
 911                                                 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
 912
 913                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 914 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 915                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 916
 917                         unlock_share_entry(conn, dev, inode);
 918                         if (fsp_open)
 919                                 fd_close(conn, fsp);
 920                         file_free(fsp);
 921                         return NULL;
 922                 }
 923
 924                 /*
 925                  * We exit this block with the share entry *locked*.....
 926                  */
 927         }
 928
 929         /*
 930          * Ensure we pay attention to default ACLs on directories if required.
 931          */
 932
 933         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
 934                         (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
 935                 mode = 0777;
 936
 937         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 938                         flags,flags2,(int)mode));
 939
 940         /*
 941          * open_file strips any O_TRUNC flags itself.
 942          */
 943
 944         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
 945
 946         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
 947                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
 948                         flags = O_RDONLY;
 949         }
 950
 951         if (!fsp_open) {
 952                 if(file_existed)
 953                         unlock_share_entry(conn, dev, inode);
 954                 file_free(fsp);
 955                 return NULL;
 956         }
 957
 958         /*
 959          * Deal with the race condition where two smbd's detect the file doesn't
 960          * exist and do the create at the same time. One of them will win and
 961          * set a share mode, the other (ie. this one) should check if the
 962          * requested share mode for this create is allowed.
 963          */
 964
 965         if (!file_existed) {
 966
 967                 lock_share_entry_fsp(fsp);
 968
 969                 num_share_modes = open_mode_check(conn, fname, dev, inode,
 970                                                   desired_access,
 971                                                   share_mode,
 972                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
 973
 974                 if(num_share_modes == -1) {
 975                         unlock_share_entry_fsp(fsp);
 976                         fd_close(conn,fsp);
 977                         file_free(fsp);
 978                         return NULL;
 979                 }
 980
 981                 /*
 982                  * If there are any share modes set then the file *did*
 983                  * exist. Ensure we return the correct value for action.
 984                  */
 985
 986                 if (num_share_modes > 0)
 987                         file_existed = True;
 988
 989                 /*
 990                  * We exit this block with the share entry *locked*.....
 991                  */
 992         }
 993
 994         /* note that we ignore failure for the following. It is
 995            basically a hack for NFS, and NFS will never set one of
 996            these only read them. Nobody but Samba can ever set a deny
 997            mode and we have already checked our more authoritative
 998            locking database for permission to set this deny mode. If
 999            the kernel refuses the operations then the kernel is wrong */
1000         kernel_flock(fsp, deny_mode);
1001
1002         /*
1003          * At this point onwards, we can guarentee that the share entry
1004          * is locked, whether we created the file or not, and that the
1005          * deny mode is compatible with all current opens.
1006          */
1007
1008         /*
1009          * If requested, truncate the file.
1010          */
1011
1012         if (flags2&O_TRUNC) {
1013                 /*
1014                  * We are modifing the file after open - update the stat struct..
1015                  */
1016                 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
1017                         unlock_share_entry_fsp(fsp);
1018                         fd_close(conn,fsp);
1019                         file_free(fsp);
1020                         return NULL;
1021                 }
1022         }
1023
1024         switch (flags) {
1025                 case O_RDONLY:
1026                         open_mode = DOS_OPEN_RDONLY;
1027                         break;
1028                 case O_RDWR:
1029                         open_mode = DOS_OPEN_RDWR;
1030                         break;
1031                 case O_WRONLY:
1032                         open_mode = DOS_OPEN_WRONLY;
1033                         break;
1034         }
1035
1036         fsp->share_mode = SET_DENY_MODE(deny_mode) |
1037                                                 SET_OPEN_MODE(open_mode) |
1038                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1039
1040         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1041
1042         if (Access)
1043                 (*Access) = open_mode;
1044
1045         if (action) {
1046                 if (file_existed && !(flags2 & O_TRUNC))
1047                         *action = FILE_WAS_OPENED;
1048                 if (!file_existed)
1049                         *action = FILE_WAS_CREATED;
1050                 if (file_existed && (flags2 & O_TRUNC))
1051                         *action = FILE_WAS_OVERWRITTEN;
1052         }
1053
1054         /*
1055          * Setup the oplock info in both the shared memory and
1056          * file structs.
1057          */
1058
1059         if(oplock_request && (num_share_modes == 0) &&
1060                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1061                 port = global_oplock_port;
1062         } else if (oplock_request && all_current_opens_are_level_II) {
1063                 port = global_oplock_port;
1064                 oplock_request = LEVEL_II_OPLOCK;
1065                 set_file_oplock(fsp, oplock_request);
1066         } else {
1067                 port = 0;
1068                 oplock_request = 0;
1069         }
1070
1071         set_share_mode(fsp, port, oplock_request);
1072
1073         if (delete_on_close) {
1074                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1075
1076                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1077                         /* Remember to delete the mode we just added. */
1078                         del_share_mode(fsp, NULL);
1079                         unlock_share_entry_fsp(fsp);
1080                         fd_close(conn,fsp);
1081                         file_free(fsp);
1082                         return NULL;
1083                 }
1084         }
1085
1086         /*
1087          * Take care of inherited ACLs on created files - if default ACL not
1088          * selected.
1089          */
1090
1091         if (!file_existed && !def_acl && (conn->vfs_ops.fchmod_acl != NULL)) {
1092                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1093                 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1094                         errno = saved_errno; /* Ignore ENOSYS */
1095         }
1096
1097         unlock_share_entry_fsp(fsp);
1098
1099         conn->num_files_open++;
1100
1101         return fsp;
1102 }
1103
1104 /****************************************************************************
1105  Open a file for for write to ensure that we can fchmod it.
1106 ****************************************************************************/
1107
1108 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1109 {
1110         files_struct *fsp = NULL;
1111         BOOL fsp_open;
1112
1113         if (!VALID_STAT(*psbuf))
1114                 return NULL;
1115
1116         fsp = file_new(conn);
1117         if(!fsp)
1118                 return NULL;
1119
1120         /* note! we must use a non-zero desired access or we don't get
1121            a real file descriptor. Oh what a twisted web we weave. */
1122         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1123
1124         /*
1125          * This is not a user visible file open.
1126          * Don't set a share mode and don't increment
1127          * the conn->num_files_open.
1128          */
1129
1130         if (!fsp_open) {
1131                 file_free(fsp);
1132                 return NULL;
1133         }
1134
1135         return fsp;
1136 }
1137
1138 /****************************************************************************
1139  Close the fchmod file fd - ensure no locks are lost.
1140 ****************************************************************************/
1141
1142 int close_file_fchmod(files_struct *fsp)
1143 {
1144         int ret = fd_close(fsp->conn, fsp);
1145         file_free(fsp);
1146         return ret;
1147 }
1148
1149 /****************************************************************************
1150  Open a directory from an NT SMB call.
1151 ****************************************************************************/
1152
1153 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1154                         uint32 desired_access, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1155 {
1156         extern struct current_user current_user;
1157         BOOL got_stat = False;
1158         files_struct *fsp = file_new(conn);
1159         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1160
1161         if(!fsp)
1162                 return NULL;
1163
1164         fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1165
1166         if (VALID_STAT(*psbuf))
1167                 got_stat = True;
1168
1169         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1170                 file_free(fsp);
1171                 errno = EEXIST; /* Setup so correct error is returned to client. */
1172                 return NULL;
1173         }
1174
1175         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1176
1177                 if (got_stat) {
1178
1179                         if(!S_ISDIR(psbuf->st_mode)) {
1180                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1181                                 file_free(fsp);
1182                                 errno = EACCES;
1183                                 return NULL;
1184                         }
1185                         *action = FILE_WAS_OPENED;
1186
1187                 } else {
1188
1189                         /*
1190                          * Try and create the directory.
1191                          */
1192
1193                         if(!CAN_WRITE(conn)) {
1194                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1195                                 file_free(fsp);
1196                                 errno = EACCES;
1197                                 return NULL;
1198                         }
1199
1200                         if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1201                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1202                                          fname, strerror(errno) ));
1203                                 file_free(fsp);
1204                                 return NULL;
1205                         }
1206
1207                         if(vfs_stat(conn,fname, psbuf) != 0) {
1208                                 file_free(fsp);
1209                                 return NULL;
1210                         }
1211
1212                         *action = FILE_WAS_CREATED;
1213
1214                 }
1215         } else {
1216
1217                 /*
1218                  * Don't create - just check that it *was* a directory.
1219                  */
1220
1221                 if(!got_stat) {
1222                         DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1223                                  fname, strerror(errno) ));
1224                         file_free(fsp);
1225                         return NULL;
1226                 }
1227
1228                 if(!S_ISDIR(psbuf->st_mode)) {
1229                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1230                         file_free(fsp);
1231                         return NULL;
1232                 }
1233
1234                 *action = FILE_WAS_OPENED;
1235         }
1236
1237         DEBUG(5,("open_directory: opening directory %s\n", fname));
1238
1239         /*
1240          * Setup the files_struct for it.
1241          */
1242
1243         fsp->mode = psbuf->st_mode;
1244         fsp->inode = psbuf->st_ino;
1245         fsp->dev = psbuf->st_dev;
1246         fsp->size = psbuf->st_size;
1247         fsp->vuid = current_user.vuid;
1248         fsp->pos = -1;
1249         fsp->can_lock = True;
1250         fsp->can_read = False;
1251         fsp->can_write = False;
1252         fsp->share_mode = share_mode;
1253         fsp->desired_access = desired_access;
1254         fsp->print_file = False;
1255         fsp->modified = False;
1256         fsp->oplock_type = NO_OPLOCK;
1257         fsp->sent_oplock_break = NO_BREAK_SENT;
1258         fsp->is_directory = True;
1259         fsp->is_stat = False;
1260         fsp->directory_delete_on_close = False;
1261         fsp->conn = conn;
1262         string_set(&fsp->fsp_name,fname);
1263
1264         if (delete_on_close) {
1265                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1266
1267                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1268                         file_free(fsp);
1269                         return NULL;
1270                 }
1271         }
1272         conn->num_files_open++;
1273
1274         return fsp;
1275 }
1276
1277 /****************************************************************************
1278  Open a pseudo-file (no locking checks - a 'stat' open).
1279 ****************************************************************************/
1280
1281 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1282 {
1283         extern struct current_user current_user;
1284         BOOL got_stat = False;
1285         files_struct *fsp = NULL;
1286
1287         if (!VALID_STAT(*psbuf))
1288                 return NULL;
1289
1290         /* Can't 'stat' open directories. */
1291         if(S_ISDIR(psbuf->st_mode))
1292                 return NULL;
1293
1294         fsp = file_new(conn);
1295         if(!fsp)
1296                 return NULL;
1297
1298         fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1299
1300         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1301
1302         /*
1303          * Setup the files_struct for it.
1304          */
1305
1306         fsp->mode = psbuf->st_mode;
1307         /*
1308          * Don't store dev or inode, we don't want any iterator
1309          * to see this.
1310          */
1311         fsp->inode = (SMB_INO_T)0;
1312         fsp->dev = (SMB_DEV_T)0;
1313         fsp->size = psbuf->st_size;
1314         fsp->vuid = current_user.vuid;
1315         fsp->pos = -1;
1316         fsp->can_lock = False;
1317         fsp->can_read = False;
1318         fsp->can_write = False;
1319         fsp->share_mode = 0;
1320         fsp->desired_access = 0;
1321         fsp->print_file = False;
1322         fsp->modified = False;
1323         fsp->oplock_type = NO_OPLOCK;
1324         fsp->sent_oplock_break = NO_BREAK_SENT;
1325         fsp->is_directory = False;
1326         fsp->is_stat = True;
1327         fsp->directory_delete_on_close = False;
1328         fsp->conn = conn;
1329         string_set(&fsp->fsp_name,fname);
1330
1331         conn->num_files_open++;
1332
1333         return fsp;
1334 }