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