source3/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
 468     broke_oplock = False;
 469     *p_all_current_opens_are_level_II = True;
 470
 471     for(i = 0; i < num_share_modes; i++) {
 472       share_mode_entry *share_entry = &old_shares[i];
 473
 474       /*
 475        * By observation of NetBench, oplocks are broken *before* share
 476        * modes are checked. This allows a file to be closed by the client
 477        * if the share mode would deny access and the client has an oplock.
 478        * Check if someone has an oplock on this file. If so we must break
 479        * it before continuing.
 480        */
 481
 482       if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 483          (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
 484
 485         BOOL opb_ret;
 486
 487         DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
 488 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 489
 490         /* Oplock break - unlock to request it. */
 491         unlock_share_entry(conn, dev, inode);
 492
 493         opb_ret = request_oplock_break(share_entry, dev, inode);
 494
 495         /* Now relock. */
 496         lock_share_entry(conn, dev, inode);
 497
 498         if(opb_ret == False) {
 499           free((char *)old_shares);
 500           DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
 501 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 502           errno = EACCES;
 503           unix_ERR_class = ERRDOS;
 504           unix_ERR_code = ERRbadshare;
 505           return -1;
 506         }
 507
 508         broke_oplock = True;
 509         break;
 510
 511       } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 512         *p_all_current_opens_are_level_II = False;
 513       }
 514
 515       /* someone else has a share lock on it, check to see
 516          if we can too */
 517
 518       if(check_share_mode(share_entry, share_mode, fname, fcbopen, p_flags) == False) {
 519         free((char *)old_shares);
 520         errno = EACCES;
 521         return -1;
 522       }
 523
 524     } /* end for */
 525
 526     if(broke_oplock) {
 527       free((char *)old_shares);
 528       num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 529       oplock_contention_count++;
 530     }
 531   } while(broke_oplock);
 532
 533   if(old_shares != 0)
 534     free((char *)old_shares);
 535
 536   /*
 537    * Refuse to grant an oplock in case the contention limit is
 538    * reached when going through the lock list multiple times.
 539    */
 540
 541   if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
 542     *p_oplock_request = 0;
 543     DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
 544           oplock_contention_count ));
 545   }
 546
 547   return num_share_modes;
 548 }
 549
 550 /****************************************************************************
 551 set a kernel flock on a file for NFS interoperability
 552 this requires a patch to Linux
 553 ****************************************************************************/
 554 static void kernel_flock(files_struct *fsp, int deny_mode)
 555 {
 556 #if HAVE_KERNEL_SHARE_MODES
 557         int kernel_mode = 0;
 558         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 559         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 560         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 561         if (kernel_mode) flock(fsp->fd, kernel_mode);
 562 #endif
 563 }
 564
 565
 566 /****************************************************************************
 567  Open a file with a share mode. On output from this open we are guarenteeing
 568  that
 569 ****************************************************************************/
 570 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 571                                 int share_mode,int ofun, mode_t mode,int oplock_request, int *Access,int *action)
 572 {
 573         int flags=0;
 574         int flags2=0;
 575         int deny_mode = GET_DENY_MODE(share_mode);
 576         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 577         BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
 578         BOOL file_existed = VALID_STAT(*psbuf);
 579         BOOL fcbopen = False;
 580         SMB_DEV_T dev = 0;
 581         SMB_INO_T inode = 0;
 582         int num_share_modes = 0;
 583         BOOL all_current_opens_are_level_II = False;
 584         BOOL fsp_open = False;
 585         files_struct *fsp = NULL;
 586         int open_mode=0;
 587         uint16 port = 0;
 588
 589         if (conn->printer) {
 590                 /* printers are handled completely differently. Most of the passed parameters are
 591                         ignored */
 592                 *Access = DOS_OPEN_WRONLY;
 593                 *action = FILE_WAS_CREATED;
 594                 return print_fsp_open(conn);
 595         }
 596
 597         fsp = file_new(conn);
 598         if(!fsp)
 599                 return NULL;
 600
 601         DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 602                 fname, share_mode, ofun, (int)mode,  oplock_request ));
 603
 604         if (!check_name(fname,conn)) {
 605                 file_free(fsp);
 606                 return NULL;
 607         }
 608
 609         /* ignore any oplock requests if oplocks are disabled */
 610         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 611                 oplock_request = 0;
 612         }
 613
 614         /* this is for OS/2 EAs - try and say we don't support them */
 615         if (strstr(fname,".+,;=[].")) {
 616                 unix_ERR_class = ERRDOS;
 617                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 618 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 619                 unix_ERR_code = ERRcannotopen;
 620 #else /* OS2_WPS_FIX */
 621                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 622 #endif /* OS2_WPS_FIX */
 623
 624                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 625                 file_free(fsp);
 626                 return NULL;
 627         }
 628
 629         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 630                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 631                         fname ));
 632                 file_free(fsp);
 633                 errno = EEXIST;
 634                 return NULL;
 635         }
 636
 637         if (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST)
 638                 flags2 |= O_CREAT;
 639
 640         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)
 641                 flags2 |= O_TRUNC;
 642
 643         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 644                 flags2 |= O_EXCL;
 645
 646         /* note that we ignore the append flag as
 647                 append does not mean the same thing under dos and unix */
 648
 649         switch (GET_OPEN_MODE(share_mode)) {
 650                 case DOS_OPEN_WRONLY:
 651                         flags = O_WRONLY;
 652                         break;
 653                 case DOS_OPEN_FCB:
 654                         fcbopen = True;
 655                         flags = O_RDWR;
 656                         break;
 657                 case DOS_OPEN_RDWR:
 658                         flags = O_RDWR;
 659                         break;
 660                 default:
 661                         flags = O_RDONLY;
 662                         break;
 663         }
 664
 665 #if defined(O_SYNC)
 666         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 667                 flags2 |= O_SYNC;
 668         }
 669 #endif /* O_SYNC */
 670
 671         if (flags != O_RDONLY && file_existed &&
 672                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 673                 if (!fcbopen) {
 674                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 675                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 676                         file_free(fsp);
 677                         errno = EACCES;
 678                         return NULL;
 679                 }
 680                 flags = O_RDONLY;
 681         }
 682
 683         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 684                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 685                 file_free(fsp);
 686                 errno = EINVAL;
 687                 return NULL;
 688         }
 689
 690         if (file_existed) {
 691
 692                 dev = psbuf->st_dev;
 693                 inode = psbuf->st_ino;
 694
 695                 lock_share_entry(conn, dev, inode);
 696
 697                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 698                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 699                 if(num_share_modes == -1) {
 700
 701                         /*
 702                          * This next line is a subtlety we need for MS-Access. If a file open will
 703                          * fail due to share permissions and also for security (access)
 704                          * reasons, we need to return the access failed error, not the
 705                          * share error. This means we must attempt to open the file anyway
 706                          * in order to get the UNIX access error - even if we're going to
 707                          * fail the open for share reasons. This is bad, as we're burning
 708                          * another fd if there are existing locks but there's nothing else
 709                          * we can do. We also ensure we're not going to create or tuncate
 710                          * the file as we only want an access decision at this stage. JRA.
 711                          */
 712                         fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
 713
 714                         DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
 715 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 716                                 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
 717
 718                         unlock_share_entry(conn, dev, inode);
 719                         if (fsp_open)
 720                                 fd_close(conn, fsp);
 721                         file_free(fsp);
 722                         return NULL;
 723                 }
 724
 725                 /*
 726                  * We exit this block with the share entry *locked*.....
 727                  */
 728         }
 729
 730         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 731                         flags,flags2,(int)mode));
 732
 733         /*
 734          * open_file strips any O_TRUNC flags itself.
 735          */
 736
 737         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode);
 738
 739         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
 740                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
 741                         flags = O_RDONLY;
 742         }
 743
 744         if (!fsp_open) {
 745                 if(file_existed)
 746                         unlock_share_entry(conn, dev, inode);
 747                 file_free(fsp);
 748                 return NULL;
 749         }
 750
 751         /*
 752          * Deal with the race condition where two smbd's detect the file doesn't
 753          * exist and do the create at the same time. One of them will win and
 754          * set a share mode, the other (ie. this one) should check if the
 755          * requested share mode for this create is allowed.
 756          */
 757
 758         if (!file_existed) {
 759
 760                 lock_share_entry_fsp(fsp);
 761
 762                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 763                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 764
 765                 if(num_share_modes == -1) {
 766                         unlock_share_entry_fsp(fsp);
 767                         fd_close(conn,fsp);
 768                         file_free(fsp);
 769                         return NULL;
 770                 }
 771
 772                 /*
 773                  * If there are any share modes set then the file *did*
 774                  * exist. Ensure we return the correct value for action.
 775                  */
 776
 777                 if (num_share_modes > 0)
 778                         file_existed = True;
 779
 780                 /*
 781                  * We exit this block with the share entry *locked*.....
 782                  */
 783         }
 784
 785         /* note that we ignore failure for the following. It is
 786            basically a hack for NFS, and NFS will never set one of
 787            these only read them. Nobody but Samba can ever set a deny
 788            mode and we have already checked our more authoritative
 789            locking database for permission to set this deny mode. If
 790            the kernel refuses the operations then the kernel is wrong */
 791         kernel_flock(fsp, deny_mode);
 792
 793         /*
 794          * At this point onwards, we can guarentee that the share entry
 795          * is locked, whether we created the file or not, and that the
 796          * deny mode is compatible with all current opens.
 797          */
 798
 799         /*
 800          * If requested, truncate the file.
 801          */
 802
 803         if (flags2&O_TRUNC) {
 804                 /*
 805                  * We are modifing the file after open - update the stat struct..
 806                  */
 807                 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
 808                         unlock_share_entry_fsp(fsp);
 809                         fd_close(conn,fsp);
 810                         file_free(fsp);
 811                         return NULL;
 812                 }
 813         }
 814
 815         switch (flags) {
 816                 case O_RDONLY:
 817                         open_mode = DOS_OPEN_RDONLY;
 818                         break;
 819                 case O_RDWR:
 820                         open_mode = DOS_OPEN_RDWR;
 821                         break;
 822                 case O_WRONLY:
 823                         open_mode = DOS_OPEN_WRONLY;
 824                         break;
 825         }
 826
 827         fsp->share_mode = SET_DENY_MODE(deny_mode) |
 828                                                 SET_OPEN_MODE(open_mode) |
 829                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
 830                                                 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
 831
 832         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
 833
 834         if (Access)
 835                 (*Access) = open_mode;
 836
 837         if (action) {
 838                 if (file_existed && !(flags2 & O_TRUNC))
 839                         *action = FILE_WAS_OPENED;
 840                 if (!file_existed)
 841                         *action = FILE_WAS_CREATED;
 842                 if (file_existed && (flags2 & O_TRUNC))
 843                         *action = FILE_WAS_OVERWRITTEN;
 844         }
 845
 846         /*
 847          * Setup the oplock info in both the shared memory and
 848          * file structs.
 849          */
 850
 851         if(oplock_request && (num_share_modes == 0) &&
 852                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
 853                 port = global_oplock_port;
 854         } else if (oplock_request && all_current_opens_are_level_II) {
 855                 port = global_oplock_port;
 856                 oplock_request = LEVEL_II_OPLOCK;
 857                 set_file_oplock(fsp, oplock_request);
 858         } else {
 859                 port = 0;
 860                 oplock_request = 0;
 861         }
 862
 863         set_share_mode(fsp, port, oplock_request);
 864
 865         unlock_share_entry_fsp(fsp);
 866
 867         conn->num_files_open++;
 868
 869         return fsp;
 870 }
 871
 872 /****************************************************************************
 873  Open a file for permissions read only. Return a pseudo file entry
 874  with the 'stat_open' flag set
 875 ****************************************************************************/
 876
 877 files_struct *open_file_stat(connection_struct *conn, char *fname,
 878                                                         SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
 879 {
 880         extern struct current_user current_user;
 881         files_struct *fsp = NULL;
 882
 883         if (!VALID_STAT(*psbuf)) {
 884                 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
 885                 return NULL;
 886         }
 887
 888         if(S_ISDIR(psbuf->st_mode)) {
 889                 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
 890                 return NULL;
 891         }
 892
 893         fsp = file_new(conn);
 894         if(!fsp)
 895                 return NULL;
 896
 897         *action = FILE_WAS_OPENED;
 898
 899         DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
 900
 901         /*
 902          * Setup the files_struct for it.
 903          */
 904
 905         fsp->fd = -1;
 906         fsp->mode = psbuf->st_mode;
 907         fsp->inode = psbuf->st_ino;
 908         fsp->dev = psbuf->st_dev;
 909         GetTimeOfDay(&fsp->open_time);
 910         fsp->size = psbuf->st_size;
 911         fsp->vuid = current_user.vuid;
 912         fsp->pos = -1;
 913         fsp->can_lock = False;
 914         fsp->can_read = False;
 915         fsp->can_write = False;
 916         fsp->share_mode = 0;
 917         fsp->print_file = False;
 918         fsp->modified = False;
 919         fsp->oplock_type = NO_OPLOCK;
 920         fsp->sent_oplock_break = NO_BREAK_SENT;
 921         fsp->is_directory = False;
 922         fsp->stat_open = True;
 923         fsp->directory_delete_on_close = False;
 924         fsp->conn = conn;
 925         string_set(&fsp->fsp_name,fname);
 926         fsp->wbmpx_ptr = NULL;
 927     fsp->wcp = NULL; /* Write cache pointer. */
 928
 929         conn->num_files_open++;
 930
 931         return fsp;
 932 }
 933
 934 /****************************************************************************
 935  Open a file for for write to ensure that we can fchmod it.
 936 ****************************************************************************/
 937
 938 files_struct *open_file_fchmod(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
 939 {
 940         files_struct *fsp = NULL;
 941         BOOL fsp_open;
 942
 943         if (!VALID_STAT(*psbuf))
 944                 return NULL;
 945
 946         fsp = file_new(conn);
 947         if(!fsp)
 948                 return NULL;
 949
 950         fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0);
 951
 952         /*
 953          * This is not a user visible file open.
 954          * Don't set a share mode and don't increment
 955          * the conn->num_files_open.
 956          */
 957
 958         if (!fsp_open) {
 959                 file_free(fsp);
 960                 return NULL;
 961         }
 962
 963         return fsp;
 964 }
 965
 966 /****************************************************************************
 967  Close the fchmod file fd - ensure no locks are lost.
 968 ****************************************************************************/
 969
 970 int close_file_fchmod(files_struct *fsp)
 971 {
 972         int ret = fd_close(fsp->conn, fsp);
 973         file_free(fsp);
 974         return ret;
 975 }
 976
 977 /****************************************************************************
 978  Open a directory from an NT SMB call.
 979 ****************************************************************************/
 980
 981 files_struct *open_directory(connection_struct *conn, char *fname,
 982                                                         SMB_STRUCT_STAT *psbuf, int smb_ofun, mode_t unixmode, int *action)
 983 {
 984         extern struct current_user current_user;
 985         BOOL got_stat = False;
 986         files_struct *fsp = file_new(conn);
 987
 988         if(!fsp)
 989                 return NULL;
 990
 991         fsp->conn = conn; /* The vfs_fXXX() macros need this. */
 992
 993         if (VALID_STAT(*psbuf))
 994                 got_stat = True;
 995
 996         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
 997                 file_free(fsp);
 998                 errno = EEXIST; /* Setup so correct error is returned to client. */
 999                 return NULL;
1000         }
1001
1002         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1003
1004                 if (got_stat) {
1005
1006                         if(!S_ISDIR(psbuf->st_mode)) {
1007                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1008                                 file_free(fsp);
1009                                 errno = EACCES;
1010                                 return NULL;
1011                         }
1012                         *action = FILE_WAS_OPENED;
1013
1014                 } else {
1015
1016                         /*
1017                          * Try and create the directory.
1018                          */
1019
1020                         if(!CAN_WRITE(conn)) {
1021                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1022                                 file_free(fsp);
1023                                 errno = EACCES;
1024                                 return NULL;
1025                         }
1026
1027                         if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1028                                 DEBUG(0,("open_directory: unable to create %s. Error was %s\n",
1029                                          fname, strerror(errno) ));
1030                                 file_free(fsp);
1031                                 return NULL;
1032                         }
1033
1034                         if(vfs_stat(conn,fname, psbuf) != 0) {
1035                                 file_free(fsp);
1036                                 return NULL;
1037                         }
1038
1039                         *action = FILE_WAS_CREATED;
1040
1041                 }
1042         } else {
1043
1044                 /*
1045                  * Don't create - just check that it *was* a directory.
1046                  */
1047
1048                 if(!got_stat) {
1049                         DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1050                                  fname, strerror(errno) ));
1051                         file_free(fsp);
1052                         return NULL;
1053                 }
1054
1055                 if(!S_ISDIR(psbuf->st_mode)) {
1056                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1057                         file_free(fsp);
1058                         return NULL;
1059                 }
1060
1061                 *action = FILE_WAS_OPENED;
1062         }
1063
1064         DEBUG(5,("open_directory: opening directory %s\n", fname));
1065
1066         /*
1067          * Setup the files_struct for it.
1068          */
1069
1070         fsp->fd = -1;
1071         fsp->mode = psbuf->st_mode;
1072         fsp->inode = psbuf->st_ino;
1073         fsp->dev = psbuf->st_dev;
1074         GetTimeOfDay(&fsp->open_time);
1075         fsp->size = psbuf->st_size;
1076         fsp->vuid = current_user.vuid;
1077         fsp->pos = -1;
1078         fsp->can_lock = True;
1079         fsp->can_read = False;
1080         fsp->can_write = False;
1081         fsp->share_mode = 0;
1082         fsp->print_file = False;
1083         fsp->modified = False;
1084         fsp->oplock_type = NO_OPLOCK;
1085         fsp->sent_oplock_break = NO_BREAK_SENT;
1086         fsp->is_directory = True;
1087         fsp->directory_delete_on_close = False;
1088         fsp->conn = conn;
1089         string_set(&fsp->fsp_name,fname);
1090         fsp->wbmpx_ptr = NULL;
1091
1092         conn->num_files_open++;
1093
1094         return fsp;
1095 }
1096
1097 /*******************************************************************
1098  Check if the share mode on a file allows it to be deleted or unlinked.
1099  Return True if sharing doesn't prevent the operation.
1100 ********************************************************************/
1101
1102 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1103 {
1104   int i;
1105   int ret = False;
1106   share_mode_entry *old_shares = 0;
1107   int num_share_modes;
1108   SMB_STRUCT_STAT sbuf;
1109   pid_t pid = sys_getpid();
1110   SMB_DEV_T dev;
1111   SMB_INO_T inode;
1112
1113   if (vfs_stat(conn,fname,&sbuf) == -1)
1114     return(True);
1115
1116   dev = sbuf.st_dev;
1117   inode = sbuf.st_ino;
1118
1119   lock_share_entry(conn, dev, inode);
1120   num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1121
1122   /*
1123    * Check if the share modes will give us access.
1124    */
1125
1126   if(num_share_modes != 0)
1127   {
1128     BOOL broke_oplock;
1129
1130     do
1131     {
1132
1133       broke_oplock = False;
1134       for(i = 0; i < num_share_modes; i++)
1135       {
1136         share_mode_entry *share_entry = &old_shares[i];
1137
1138         /*
1139          * Break oplocks before checking share modes. See comment in
1140          * open_file_shared for details.
1141          * Check if someone has an oplock on this file. If so we must
1142          * break it before continuing.
1143          */
1144         if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1145         {
1146
1147 #if 0
1148
1149 /* JRA. Try removing this code to see if the new oplock changes
1150    fix the problem. I'm dubious, but Andrew is recommending we
1151    try this....
1152 */
1153
1154           /*
1155            * It appears that the NT redirector may have a bug, in that
1156            * it tries to do an SMBmv on a file that it has open with a
1157            * batch oplock, and then fails to respond to the oplock break
1158            * request. This only seems to occur when the client is doing an
1159            * SMBmv to the smbd it is using - thus we try and detect this
1160            * condition by checking if the file being moved is open and oplocked by
1161            * this smbd process, and then not sending the oplock break in this
1162            * special case. If the file was open with a deny mode that
1163            * prevents the move the SMBmv will fail anyway with a share
1164            * violation error. JRA.
1165            */
1166           if(rename_op && (share_entry->pid == pid))
1167           {
1168
1169             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1170 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1171
1172             /*
1173              * This next line is a test that allows the deny-mode
1174              * processing to be skipped. This seems to be needed as
1175              * NT insists on the rename succeeding (in Office 9x no less !).
1176              * This should be removed as soon as (a) MS fix the redirector
1177              * bug or (b) NT SMB support in Samba makes NT not issue the
1178              * call (as is my fervent hope). JRA.
1179              */
1180             continue;
1181           }
1182           else
1183 #endif /* 0 */
1184           {
1185
1186             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1187 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1188
1189             /* Oplock break.... */
1190             unlock_share_entry(conn, dev, inode);
1191             if(request_oplock_break(share_entry, dev, inode) == False)
1192             {
1193               free((char *)old_shares);
1194
1195               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1196 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1197
1198               return False;
1199             }
1200             lock_share_entry(conn, dev, inode);
1201             broke_oplock = True;
1202             break;
1203           }
1204         }
1205
1206         /*
1207          * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1208          * this to proceed. This takes precedence over share modes.
1209          */
1210
1211         if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1212           continue;
1213
1214         /*
1215          * Someone else has a share lock on it, check to see
1216          * if we can too.
1217          */
1218
1219         if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1220             (share_entry->pid != pid))
1221           goto free_and_exit;
1222
1223       } /* end for */
1224
1225       if(broke_oplock)
1226       {
1227         free((char *)old_shares);
1228         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1229       }
1230     } while(broke_oplock);
1231   }
1232
1233   /* XXXX exactly what share mode combinations should be allowed for
1234      deleting/renaming? */
1235   /*
1236    * If we got here then either there were no share modes or
1237    * all share modes were DENY_DOS and the pid == getpid() or
1238    * delete access was requested and all share modes had the
1239    * ALLOW_SHARE_DELETE bit set (takes precedence over other
1240    * share modes).
1241    */
1242
1243   ret = True;
1244
1245 free_and_exit:
1246
1247   unlock_share_entry(conn, dev, inode);
1248   if(old_shares != NULL)
1249     free((char *)old_shares);
1250   return(ret);
1251 }