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