source/smbd/open.c

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