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                 if (S_ISDIR(psbuf->st_mode)) {
 870                         errno = EISDIR;
 871                 } else {
 872                         errno = EEXIST;
 873                 }
 874                 return NULL;
 875         }
 876
 877         if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
 878                 flags2 |= O_CREAT;
 879
 880         if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
 881                 flags2 |= O_TRUNC;
 882
 883         /* We only care about matching attributes on file exists and truncate. */
 884         if (file_existed && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)) {
 885                 if (!open_match_attributes(conn, fname, psbuf->st_mode, mode, &new_mode)) {
 886                         DEBUG(5,("open_file_shared: attributes missmatch for file %s (0%o, 0%o)\n",
 887                                                 fname, (int)psbuf->st_mode, (int)mode ));
 888                         file_free(fsp);
 889                         errno = EACCES;
 890                         return NULL;
 891                 }
 892         }
 893
 894         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 895                 flags2 |= O_EXCL;
 896
 897         /* note that we ignore the append flag as
 898                 append does not mean the same thing under dos and unix */
 899
 900         switch (GET_OPEN_MODE(share_mode)) {
 901                 case DOS_OPEN_WRONLY:
 902                         flags = O_WRONLY;
 903                         if (desired_access == 0)
 904                                 desired_access = FILE_WRITE_DATA;
 905                         break;
 906                 case DOS_OPEN_FCB:
 907                         fcbopen = True;
 908                         flags = O_RDWR;
 909                         if (desired_access == 0)
 910                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 911                         break;
 912                 case DOS_OPEN_RDWR:
 913                         flags = O_RDWR;
 914                         if (desired_access == 0)
 915                                 desired_access = FILE_READ_DATA|FILE_WRITE_DATA;
 916                         break;
 917                 default:
 918                         flags = O_RDONLY;
 919                         if (desired_access == 0)
 920                                 desired_access = FILE_READ_DATA;
 921                         break;
 922         }
 923
 924 #if defined(O_SYNC)
 925         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 926                 flags2 |= O_SYNC;
 927         }
 928 #endif /* O_SYNC */
 929
 930         if (flags != O_RDONLY && file_existed &&
 931                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 932                 if (!fcbopen) {
 933                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 934                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 935                         file_free(fsp);
 936                         errno = EACCES;
 937                         return NULL;
 938                 }
 939                 flags = O_RDONLY;
 940         }
 941
 942         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 943                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 944                 file_free(fsp);
 945                 errno = EINVAL;
 946                 return NULL;
 947         }
 948
 949         if (file_existed) {
 950
 951                 dev = psbuf->st_dev;
 952                 inode = psbuf->st_ino;
 953
 954                 lock_share_entry(conn, dev, inode);
 955
 956                 num_share_modes = open_mode_check(conn, fname, dev, inode,
 957                                                   desired_access,
 958                                                   share_mode,
 959                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
 960                 if(num_share_modes == -1) {
 961
 962                         /*
 963                          * This next line is a subtlety we need for MS-Access. If a file open will
 964                          * fail due to share permissions and also for security (access)
 965                          * reasons, we need to return the access failed error, not the
 966                          * share error. This means we must attempt to open the file anyway
 967                          * in order to get the UNIX access error - even if we're going to
 968                          * fail the open for share reasons. This is bad, as we're burning
 969                          * another fd if there are existing locks but there's nothing else
 970                          * we can do. We also ensure we're not going to create or tuncate
 971                          * the file as we only want an access decision at this stage. JRA.
 972                          */
 973                         errno = 0;
 974                         fsp_open = open_file(fsp,conn,fname,psbuf,
 975                                                 flags|(flags2&~(O_TRUNC|O_CREAT)),mode,desired_access);
 976
 977                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 978 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 979                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 980
 981                         if (!fsp_open && errno) {
 982                                 unix_ERR_class = ERRDOS;
 983                                 unix_ERR_code = ERRnoaccess;
 984                                 unix_ERR_ntstatus = NT_STATUS_ACCESS_DENIED;
 985                         }
 986
 987                         unlock_share_entry(conn, dev, inode);
 988                         if (fsp_open)
 989                                 fd_close(conn, fsp);
 990                         file_free(fsp);
 991                         return NULL;
 992                 }
 993
 994                 /*
 995                  * We exit this block with the share entry *locked*.....
 996                  */
 997         }
 998
 999         /*
1000          * Ensure we pay attention to default ACLs on directories if required.
1001          */
1002
1003         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1004                         (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
1005                 mode = 0777;
1006
1007         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1008                         flags,flags2,(int)mode));
1009
1010         /*
1011          * open_file strips any O_TRUNC flags itself.
1012          */
1013
1014         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode,desired_access);
1015
1016         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
1017                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode,desired_access)) == True)
1018                         flags = O_RDONLY;
1019         }
1020
1021         if (!fsp_open) {
1022                 if(file_existed)
1023                         unlock_share_entry(conn, dev, inode);
1024                 file_free(fsp);
1025                 return NULL;
1026         }
1027
1028         /*
1029          * Deal with the race condition where two smbd's detect the file doesn't
1030          * exist and do the create at the same time. One of them will win and
1031          * set a share mode, the other (ie. this one) should check if the
1032          * requested share mode for this create is allowed.
1033          */
1034
1035         if (!file_existed) {
1036
1037                 /*
1038                  * Now the file exists and fsp is successfully opened,
1039                  * fsp->dev and fsp->inode are valid and should replace the
1040                  * dev=0,inode=0 from a non existent file. Spotted by
1041                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1042                  */
1043
1044                 dev = fsp->dev;
1045                 inode = fsp->inode;
1046
1047                 lock_share_entry_fsp(fsp);
1048
1049                 num_share_modes = open_mode_check(conn, fname, dev, inode,
1050                                                   desired_access,
1051                                                   share_mode,
1052                                                   &flags, &oplock_request, &all_current_opens_are_level_II);
1053
1054                 if(num_share_modes == -1) {
1055                         unlock_share_entry_fsp(fsp);
1056                         fd_close(conn,fsp);
1057                         file_free(fsp);
1058                         return NULL;
1059                 }
1060
1061                 /*
1062                  * If there are any share modes set then the file *did*
1063                  * exist. Ensure we return the correct value for action.
1064                  */
1065
1066                 if (num_share_modes > 0)
1067                         file_existed = True;
1068
1069                 /*
1070                  * We exit this block with the share entry *locked*.....
1071                  */
1072         }
1073
1074         /* note that we ignore failure for the following. It is
1075            basically a hack for NFS, and NFS will never set one of
1076            these only read them. Nobody but Samba can ever set a deny
1077            mode and we have already checked our more authoritative
1078            locking database for permission to set this deny mode. If
1079            the kernel refuses the operations then the kernel is wrong */
1080         kernel_flock(fsp, deny_mode);
1081
1082         /*
1083          * At this point onwards, we can guarentee that the share entry
1084          * is locked, whether we created the file or not, and that the
1085          * deny mode is compatible with all current opens.
1086          */
1087
1088         /*
1089          * If requested, truncate the file.
1090          */
1091
1092         if (flags2&O_TRUNC) {
1093                 /*
1094                  * We are modifing the file after open - update the stat struct..
1095                  */
1096                 if ((truncate_unless_locked(conn,fsp) == -1) || (SMB_VFS_FSTAT(fsp,fsp->fd,psbuf)==-1)) {
1097                         unlock_share_entry_fsp(fsp);
1098                         fd_close(conn,fsp);
1099                         file_free(fsp);
1100                         return NULL;
1101                 }
1102         }
1103
1104         switch (flags) {
1105                 case O_RDONLY:
1106                         open_mode = DOS_OPEN_RDONLY;
1107                         break;
1108                 case O_RDWR:
1109                         open_mode = DOS_OPEN_RDWR;
1110                         break;
1111                 case O_WRONLY:
1112                         open_mode = DOS_OPEN_WRONLY;
1113                         break;
1114         }
1115
1116         fsp->share_mode = SET_DENY_MODE(deny_mode) |
1117                                                 SET_OPEN_MODE(open_mode) |
1118                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete);
1119
1120         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
1121
1122         if (Access)
1123                 (*Access) = open_mode;
1124
1125         if (action) {
1126                 if (file_existed && !(flags2 & O_TRUNC))
1127                         *action = FILE_WAS_OPENED;
1128                 if (!file_existed)
1129                         *action = FILE_WAS_CREATED;
1130                 if (file_existed && (flags2 & O_TRUNC))
1131                         *action = FILE_WAS_OVERWRITTEN;
1132         }
1133
1134         /*
1135          * Setup the oplock info in both the shared memory and
1136          * file structs.
1137          */
1138
1139         if(oplock_request && (num_share_modes == 0) &&
1140                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1141                 port = global_oplock_port;
1142         } else if (oplock_request && all_current_opens_are_level_II) {
1143                 port = global_oplock_port;
1144                 oplock_request = LEVEL_II_OPLOCK;
1145                 set_file_oplock(fsp, oplock_request);
1146         } else {
1147                 port = 0;
1148                 oplock_request = 0;
1149         }
1150
1151         set_share_mode(fsp, port, oplock_request);
1152
1153         if (delete_on_close) {
1154                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1155
1156                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1157                         /* Remember to delete the mode we just added. */
1158                         del_share_mode(fsp, NULL);
1159                         unlock_share_entry_fsp(fsp);
1160                         fd_close(conn,fsp);
1161                         file_free(fsp);
1162                         return NULL;
1163                 }
1164         }
1165
1166         /*
1167          * Take care of inherited ACLs on created files - if default ACL not
1168          * selected.
1169          */
1170
1171         if (!file_existed && !def_acl) {
1172
1173                 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1174
1175                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
1176                         errno = saved_errno; /* Ignore ENOSYS */
1177
1178         } else if (new_mode) {
1179
1180                 int ret = -1;
1181
1182                 /* Attributes need changing. File already existed. */
1183
1184                 {
1185                         int saved_errno = errno; /* We might get ENOSYS in the next call.. */
1186                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fd, new_mode);
1187
1188                         if (ret == -1 && errno == ENOSYS) {
1189                                 errno = saved_errno; /* Ignore ENOSYS */
1190                         } else {
1191                                 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1192                                         fname, (int)new_mode));
1193                                 ret = 0; /* Don't do the fchmod below. */
1194                         }
1195                 }
1196
1197                 if ((ret == -1) && (SMB_VFS_FCHMOD(fsp, fsp->fd, new_mode) == -1))
1198                         DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1199                                 fname, (int)new_mode));
1200         }
1201
1202         unlock_share_entry_fsp(fsp);
1203
1204         conn->num_files_open++;
1205
1206         return fsp;
1207 }
1208
1209 /****************************************************************************
1210  Open a file for for write to ensure that we can fchmod it.
1211 ****************************************************************************/
1212
1213 files_struct *open_file_fchmod(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *psbuf)
1214 {
1215         files_struct *fsp = NULL;
1216         BOOL fsp_open;
1217
1218         if (!VALID_STAT(*psbuf))
1219                 return NULL;
1220
1221         fsp = file_new(conn);
1222         if(!fsp)
1223                 return NULL;
1224
1225         /* note! we must use a non-zero desired access or we don't get
1226            a real file descriptor. Oh what a twisted web we weave. */
1227         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1228
1229         /*
1230          * This is not a user visible file open.
1231          * Don't set a share mode and don't increment
1232          * the conn->num_files_open.
1233          */
1234
1235         if (!fsp_open) {
1236                 file_free(fsp);
1237                 return NULL;
1238         }
1239
1240         return fsp;
1241 }
1242
1243 /****************************************************************************
1244  Close the fchmod file fd - ensure no locks are lost.
1245 ****************************************************************************/
1246
1247 int close_file_fchmod(files_struct *fsp)
1248 {
1249         int ret = fd_close(fsp->conn, fsp);
1250         file_free(fsp);
1251         return ret;
1252 }
1253
1254 /****************************************************************************
1255  Open a directory from an NT SMB call.
1256 ****************************************************************************/
1257
1258 files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf,
1259                         uint32 desired_access, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1260 {
1261         extern struct current_user current_user;
1262         BOOL got_stat = False;
1263         files_struct *fsp = file_new(conn);
1264         BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1265
1266         if(!fsp)
1267                 return NULL;
1268
1269         if (VALID_STAT(*psbuf))
1270                 got_stat = True;
1271
1272         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1273                 file_free(fsp);
1274                 errno = EEXIST; /* Setup so correct error is returned to client. */
1275                 return NULL;
1276         }
1277
1278         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1279
1280                 if (got_stat) {
1281
1282                         if(!S_ISDIR(psbuf->st_mode)) {
1283                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1284                                 file_free(fsp);
1285                                 errno = EACCES;
1286                                 return NULL;
1287                         }
1288                         *action = FILE_WAS_OPENED;
1289
1290                 } else {
1291
1292                         /*
1293                          * Try and create the directory.
1294                          */
1295
1296                         if(!CAN_WRITE(conn)) {
1297                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1298                                 file_free(fsp);
1299                                 errno = EACCES;
1300                                 return NULL;
1301                         }
1302
1303                         if (ms_has_wild(fname))  {
1304                                 file_free(fsp);
1305                                 DEBUG(5,("open_directory: failing create on filename %s with wildcards\n", fname));
1306                                 unix_ERR_class = ERRDOS;
1307                                 unix_ERR_code = ERRinvalidname;
1308                                 unix_ERR_ntstatus = NT_STATUS_OBJECT_NAME_INVALID;
1309                                 return NULL;
1310                         }
1311
1312                         if( strchr_m(fname, ':')) {
1313                                 file_free(fsp);
1314                                 DEBUG(5,("open_directory: failing create on filename %s with colon in name\n", fname));
1315                                 unix_ERR_class = ERRDOS;
1316                                 unix_ERR_code = ERRinvalidname;
1317                                 unix_ERR_ntstatus = NT_STATUS_NOT_A_DIRECTORY;
1318                                 return NULL;
1319                         }
1320
1321                         if(vfs_MkDir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1322                                 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1323                                          fname, strerror(errno) ));
1324                                 file_free(fsp);
1325                                 return NULL;
1326                         }
1327
1328                         if(SMB_VFS_STAT(conn,fname, psbuf) != 0) {
1329                                 file_free(fsp);
1330                                 return NULL;
1331                         }
1332
1333                         *action = FILE_WAS_CREATED;
1334
1335                 }
1336         } else {
1337
1338                 /*
1339                  * Don't create - just check that it *was* a directory.
1340                  */
1341
1342                 if(!got_stat) {
1343                         DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1344                                  fname, strerror(errno) ));
1345                         file_free(fsp);
1346                         return NULL;
1347                 }
1348
1349                 if(!S_ISDIR(psbuf->st_mode)) {
1350                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1351                         file_free(fsp);
1352                         return NULL;
1353                 }
1354
1355                 *action = FILE_WAS_OPENED;
1356         }
1357
1358         DEBUG(5,("open_directory: opening directory %s\n", fname));
1359
1360         /*
1361          * Setup the files_struct for it.
1362          */
1363
1364         fsp->mode = psbuf->st_mode;
1365         fsp->inode = psbuf->st_ino;
1366         fsp->dev = psbuf->st_dev;
1367         fsp->size = psbuf->st_size;
1368         fsp->vuid = current_user.vuid;
1369         fsp->file_pid = global_smbpid;
1370         fsp->can_lock = True;
1371         fsp->can_read = False;
1372         fsp->can_write = False;
1373         fsp->share_mode = share_mode;
1374         fsp->desired_access = desired_access;
1375         fsp->print_file = False;
1376         fsp->modified = False;
1377         fsp->oplock_type = NO_OPLOCK;
1378         fsp->sent_oplock_break = NO_BREAK_SENT;
1379         fsp->is_directory = True;
1380         fsp->is_stat = False;
1381         fsp->directory_delete_on_close = False;
1382         string_set(&fsp->fsp_name,fname);
1383
1384         if (delete_on_close) {
1385                 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1386
1387                 if (NT_STATUS_V(result) !=  NT_STATUS_V(NT_STATUS_OK)) {
1388                         file_free(fsp);
1389                         return NULL;
1390                 }
1391         }
1392         conn->num_files_open++;
1393
1394         return fsp;
1395 }
1396
1397 /****************************************************************************
1398  Open a pseudo-file (no locking checks - a 'stat' open).
1399 ****************************************************************************/
1400
1401 files_struct *open_file_stat(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1402 {
1403         extern struct current_user current_user;
1404         files_struct *fsp = NULL;
1405
1406         if (!VALID_STAT(*psbuf))
1407                 return NULL;
1408
1409         /* Can't 'stat' open directories. */
1410         if(S_ISDIR(psbuf->st_mode))
1411                 return NULL;
1412
1413         fsp = file_new(conn);
1414         if(!fsp)
1415                 return NULL;
1416
1417         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
1418
1419         /*
1420          * Setup the files_struct for it.
1421          */
1422
1423         fsp->mode = psbuf->st_mode;
1424         /*
1425          * Don't store dev or inode, we don't want any iterator
1426          * to see this.
1427          */
1428         fsp->inode = (SMB_INO_T)0;
1429         fsp->dev = (SMB_DEV_T)0;
1430         fsp->size = psbuf->st_size;
1431         fsp->vuid = current_user.vuid;
1432         fsp->file_pid = global_smbpid;
1433         fsp->can_lock = False;
1434         fsp->can_read = False;
1435         fsp->can_write = False;
1436         fsp->share_mode = 0;
1437         fsp->desired_access = 0;
1438         fsp->print_file = False;
1439         fsp->modified = False;
1440         fsp->oplock_type = NO_OPLOCK;
1441         fsp->sent_oplock_break = NO_BREAK_SENT;
1442         fsp->is_directory = False;
1443         fsp->is_stat = True;
1444         fsp->directory_delete_on_close = False;
1445         string_set(&fsp->fsp_name,fname);
1446
1447         conn->num_files_open++;
1448
1449         return fsp;
1450 }