source/smbd/open.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    file opening and share modes
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int DEBUGLEVEL;
  25
  26 extern userdom_struct current_user_info;
  27 extern uint16 global_oplock_port;
  28 extern BOOL global_client_failed_oplock_break;
  29
  30 /****************************************************************************
  31  fd support routines - attempt to do a dos_open.
  32 ****************************************************************************/
  33
  34 static int fd_open(struct connection_struct *conn, char *fname,
  35                    int flags, mode_t mode)
  36 {
  37         int fd;
  38 #ifdef O_NONBLOCK
  39         flags |= O_NONBLOCK;
  40 #endif
  41
  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 share_mode,
 345                              const char *fname, BOOL fcbopen, int *flags)
 346 {
 347         int deny_mode = GET_DENY_MODE(share_mode);
 348         int old_open_mode = GET_OPEN_MODE(share->share_mode);
 349         int old_deny_mode = GET_DENY_MODE(share->share_mode);
 350
 351         /*
 352          * Don't allow any opens once the delete on close flag has been
 353          * set.
 354          */
 355
 356         if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
 357                 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
 358                         fname ));
 359                 unix_ERR_class = ERRDOS;
 360                 unix_ERR_code = ERRnoaccess;
 361                 return False;
 362         }
 363
 364         /*
 365          * If delete access was requested and the existing share mode doesn't have
 366          * ALLOW_SHARE_DELETE then deny.
 367          */
 368
 369         if (GET_DELETE_ACCESS_REQUESTED(share_mode) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
 370                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
 371                         fname ));
 372                 unix_ERR_class = ERRDOS;
 373                 unix_ERR_code = ERRbadshare;
 374
 375                 return False;
 376         }
 377
 378         /*
 379          * The inverse of the above.
 380          * If delete access was granted and the new share mode doesn't have
 381          * ALLOW_SHARE_DELETE then deny.
 382          */
 383
 384         if (GET_DELETE_ACCESS_REQUESTED(share->share_mode) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
 385                 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
 386                         fname ));
 387                 unix_ERR_class = ERRDOS;
 388                 unix_ERR_code = ERRbadshare;
 389
 390                 return False;
 391         }
 392
 393         {
 394                 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
 395                                                                                 (share->pid == sys_getpid()),is_executable(fname));
 396
 397                 if ((access_allowed == AFAIL) ||
 398                         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
 399                         (access_allowed == AREAD && *flags != O_RDONLY) ||
 400                         (access_allowed == AWRITE && *flags != O_WRONLY)) {
 401
 402                         DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
 403                                 deny_mode,old_deny_mode,old_open_mode,
 404                                 (int)share->pid,fname, fcbopen, *flags, access_allowed));
 405
 406                         unix_ERR_class = ERRDOS;
 407                         unix_ERR_code = ERRbadshare;
 408
 409                         return False;
 410                 }
 411
 412                 if (access_allowed == AREAD)
 413                         *flags = O_RDONLY;
 414
 415                 if (access_allowed == AWRITE)
 416                         *flags = O_WRONLY;
 417
 418         }
 419
 420         return True;
 421 }
 422
 423 /****************************************************************************
 424  Deal with open deny mode and oplock break processing.
 425  Invarient: Share mode must be locked on entry and exit.
 426  Returns -1 on error, or number of share modes on success (may be zero).
 427 ****************************************************************************/
 428
 429 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
 430                                                         SMB_INO_T inode, int share_mode, int *p_flags, int *p_oplock_request,
 431                                                         BOOL *p_all_current_opens_are_level_II)
 432 {
 433   int i;
 434   int num_share_modes;
 435   int oplock_contention_count = 0;
 436   share_mode_entry *old_shares = 0;
 437   BOOL fcbopen = False;
 438   BOOL broke_oplock;
 439
 440   if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
 441     fcbopen = True;
 442
 443   num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 444
 445   if(num_share_modes == 0)
 446     return 0;
 447
 448   /*
 449    * Check if the share modes will give us access.
 450    */
 451
 452   do {
 453
 454     broke_oplock = False;
 455     *p_all_current_opens_are_level_II = True;
 456
 457     for(i = 0; i < num_share_modes; i++) {
 458       share_mode_entry *share_entry = &old_shares[i];
 459
 460       /*
 461        * By observation of NetBench, oplocks are broken *before* share
 462        * modes are checked. This allows a file to be closed by the client
 463        * if the share mode would deny access and the client has an oplock.
 464        * Check if someone has an oplock on this file. If so we must break
 465        * it before continuing.
 466        */
 467
 468       if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 469          (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
 470
 471         BOOL opb_ret;
 472
 473         DEBUG(5,("open_mode_check: breaking oplock (%x) on file %s, \
 474 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 475
 476         /* Oplock break - unlock to request it. */
 477         unlock_share_entry(conn, dev, inode);
 478
 479         opb_ret = request_oplock_break(share_entry, dev, inode);
 480
 481         /* Now relock. */
 482         lock_share_entry(conn, dev, inode);
 483
 484         if(opb_ret == False) {
 485           free((char *)old_shares);
 486           DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
 487 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 488           errno = EACCES;
 489           unix_ERR_class = ERRDOS;
 490           unix_ERR_code = ERRbadshare;
 491           return -1;
 492         }
 493
 494         broke_oplock = True;
 495         *p_all_current_opens_are_level_II = False;
 496         break;
 497
 498       } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 499         *p_all_current_opens_are_level_II = False;
 500       }
 501
 502       /* someone else has a share lock on it, check to see
 503          if we can too */
 504
 505       if(check_share_mode(share_entry, share_mode, fname, fcbopen, p_flags) == False) {
 506         free((char *)old_shares);
 507         errno = EACCES;
 508         return -1;
 509       }
 510
 511     } /* end for */
 512
 513     if(broke_oplock) {
 514       free((char *)old_shares);
 515       num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 516       oplock_contention_count++;
 517     }
 518   } while(broke_oplock);
 519
 520   if(old_shares != 0)
 521     free((char *)old_shares);
 522
 523   /*
 524    * Refuse to grant an oplock in case the contention limit is
 525    * reached when going through the lock list multiple times.
 526    */
 527
 528   if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
 529     *p_oplock_request = 0;
 530     DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
 531           oplock_contention_count ));
 532   }
 533
 534   return num_share_modes;
 535 }
 536
 537 /****************************************************************************
 538 set a kernel flock on a file for NFS interoperability
 539 this requires a patch to Linux
 540 ****************************************************************************/
 541 static void kernel_flock(files_struct *fsp, int deny_mode)
 542 {
 543 #if HAVE_KERNEL_SHARE_MODES
 544         int kernel_mode = 0;
 545         if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
 546         else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
 547         else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
 548         if (kernel_mode) flock(fsp->fd, kernel_mode);
 549 #endif
 550 }
 551
 552
 553 /****************************************************************************
 554  Open a file with a share mode. On output from this open we are guarenteeing
 555  that
 556 ****************************************************************************/
 557 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
 558                                 int share_mode,int ofun, mode_t mode,int oplock_request, int *Access,int *action)
 559 {
 560         int flags=0;
 561         int flags2=0;
 562         int deny_mode = GET_DENY_MODE(share_mode);
 563         BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 564         BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
 565         BOOL file_existed = VALID_STAT(*psbuf);
 566         BOOL fcbopen = False;
 567         SMB_DEV_T dev = 0;
 568         SMB_INO_T inode = 0;
 569         int num_share_modes = 0;
 570         BOOL all_current_opens_are_level_II = False;
 571         BOOL fsp_open = False;
 572         files_struct *fsp = NULL;
 573         int open_mode=0;
 574         uint16 port = 0;
 575
 576         if (conn->printer) {
 577                 /* printers are handled completely differently. Most of the passed parameters are
 578                         ignored */
 579                 *Access = DOS_OPEN_WRONLY;
 580                 *action = FILE_WAS_CREATED;
 581                 return print_fsp_open(conn, fname);
 582         }
 583
 584         fsp = file_new();
 585         if(!fsp)
 586                 return NULL;
 587
 588         fsp->fd = -1;
 589         fsp->conn = conn; /* The vfs_fXXX() macros need this. */
 590
 591         DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 592                 fname, share_mode, ofun, (int)mode,  oplock_request ));
 593
 594         if (!check_name(fname,conn)) {
 595                 file_free(fsp);
 596                 return NULL;
 597         }
 598
 599         /* ignore any oplock requests if oplocks are disabled */
 600         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 601                 oplock_request = 0;
 602         }
 603
 604         /* this is for OS/2 EAs - try and say we don't support them */
 605         if (strstr(fname,".+,;=[].")) {
 606                 unix_ERR_class = ERRDOS;
 607                 /* OS/2 Workplace shell fix may be main code stream in a later release. */
 608 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 609                 unix_ERR_code = ERRcannotopen;
 610 #else /* OS2_WPS_FIX */
 611                 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 612 #endif /* OS2_WPS_FIX */
 613
 614                 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 615                 file_free(fsp);
 616                 return NULL;
 617         }
 618
 619         if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)  {
 620                 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 621                         fname ));
 622                 file_free(fsp);
 623                 errno = EEXIST;
 624                 return NULL;
 625         }
 626
 627         if (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST)
 628                 flags2 |= O_CREAT;
 629
 630         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)
 631                 flags2 |= O_TRUNC;
 632
 633         if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 634                 flags2 |= O_EXCL;
 635
 636         /* note that we ignore the append flag as
 637                 append does not mean the same thing under dos and unix */
 638
 639         switch (GET_OPEN_MODE(share_mode)) {
 640                 case DOS_OPEN_WRONLY:
 641                         flags = O_WRONLY;
 642                         break;
 643                 case DOS_OPEN_FCB:
 644                         fcbopen = True;
 645                         flags = O_RDWR;
 646                         break;
 647                 case DOS_OPEN_RDWR:
 648                         flags = O_RDWR;
 649                         break;
 650                 default:
 651                         flags = O_RDONLY;
 652                         break;
 653         }
 654
 655 #if defined(O_SYNC)
 656         if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 657                 flags2 |= O_SYNC;
 658         }
 659 #endif /* O_SYNC */
 660
 661         if (flags != O_RDONLY && file_existed &&
 662                         (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
 663                 if (!fcbopen) {
 664                         DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 665                                 fname, !CAN_WRITE(conn) ? "share" : "file" ));
 666                         file_free(fsp);
 667                         errno = EACCES;
 668                         return NULL;
 669                 }
 670                 flags = O_RDONLY;
 671         }
 672
 673         if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
 674                 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 675                 file_free(fsp);
 676                 errno = EINVAL;
 677                 return NULL;
 678         }
 679
 680         if (file_existed) {
 681
 682                 dev = psbuf->st_dev;
 683                 inode = psbuf->st_ino;
 684
 685                 lock_share_entry(conn, dev, inode);
 686
 687                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 688                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 689                 if(num_share_modes == -1) {
 690
 691                         /*
 692                          * This next line is a subtlety we need for MS-Access. If a file open will
 693                          * fail due to share permissions and also for security (access)
 694                          * reasons, we need to return the access failed error, not the
 695                          * share error. This means we must attempt to open the file anyway
 696                          * in order to get the UNIX access error - even if we're going to
 697                          * fail the open for share reasons. This is bad, as we're burning
 698                          * another fd if there are existing locks but there's nothing else
 699                          * we can do. We also ensure we're not going to create or tuncate
 700                          * the file as we only want an access decision at this stage. JRA.
 701                          */
 702                         open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
 703
 704                         unlock_share_entry(conn, dev, inode);
 705                         file_free(fsp);
 706                         return NULL;
 707                 }
 708
 709                 /*
 710                  * We exit this block with the share entry *locked*.....
 711                  */
 712         }
 713
 714         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 715                         flags,flags2,(int)mode));
 716
 717         fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC)),mode);
 718
 719         if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
 720                 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
 721                         flags = O_RDONLY;
 722         }
 723
 724         if (!fsp_open) {
 725                 if(file_existed)
 726                         unlock_share_entry(conn, dev, inode);
 727                 file_free(fsp);
 728                 return NULL;
 729         }
 730
 731         /*
 732          * Deal with the race condition where two smbd's detect the file doesn't
 733          * exist and do the create at the same time. One of them will win and
 734          * set a share mode, the other (ie. this one) should check if the
 735          * requested share mode for this create is allowed.
 736          */
 737
 738         if (!file_existed) {
 739
 740                 lock_share_entry_fsp(fsp);
 741
 742                 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
 743                                                                 &flags, &oplock_request, &all_current_opens_are_level_II);
 744
 745                 if(num_share_modes == -1) {
 746                         unlock_share_entry_fsp(fsp);
 747                         fd_close(conn,fsp);
 748                         file_free(fsp);
 749                         return NULL;
 750                 }
 751
 752                 /*
 753                  * We exit this block with the share entry *locked*.....
 754                  */
 755         }
 756
 757         /* note that we ignore failure for the following. It is
 758            basically a hack for NFS, and NFS will never set one of
 759            these only read them. Nobody but Samba can ever set a deny
 760            mode and we have already checked our more authoritative
 761            locking database for permission to set this deny mode. If
 762            the kernel refuses the operations then the kernel is wrong */
 763         kernel_flock(fsp, deny_mode);
 764
 765         /*
 766          * At this point onwards, we can guarentee that the share entry
 767          * is locked, whether we created the file or not, and that the
 768          * deny mode is compatible with all current opens.
 769          */
 770
 771         /*
 772          * If requested, truncate the file.
 773          */
 774
 775         if (flags2&O_TRUNC) {
 776                 /*
 777                  * We are modifing the file after open - update the stat struct..
 778                  */
 779                 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
 780                         unlock_share_entry_fsp(fsp);
 781                         fd_close(conn,fsp);
 782                         file_free(fsp);
 783                         return NULL;
 784                 }
 785         }
 786
 787         switch (flags) {
 788                 case O_RDONLY:
 789                         open_mode = DOS_OPEN_RDONLY;
 790                         break;
 791                 case O_RDWR:
 792                         open_mode = DOS_OPEN_RDWR;
 793                         break;
 794                 case O_WRONLY:
 795                         open_mode = DOS_OPEN_WRONLY;
 796                         break;
 797         }
 798
 799         fsp->share_mode = SET_DENY_MODE(deny_mode) |
 800                                                 SET_OPEN_MODE(open_mode) |
 801                                                 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
 802                                                 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
 803
 804         DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
 805
 806         if (Access)
 807                 (*Access) = open_mode;
 808
 809         if (action) {
 810                 if (file_existed && !(flags2 & O_TRUNC))
 811                         *action = FILE_WAS_OPENED;
 812                 if (!file_existed)
 813                         *action = FILE_WAS_CREATED;
 814                 if (file_existed && (flags2 & O_TRUNC))
 815                         *action = FILE_WAS_OVERWRITTEN;
 816         }
 817
 818         /*
 819          * Setup the oplock info in both the shared memory and
 820          * file structs.
 821          */
 822
 823         if(oplock_request && (num_share_modes == 0) &&
 824                         !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
 825                 port = global_oplock_port;
 826         } else if (oplock_request && all_current_opens_are_level_II) {
 827                 port = global_oplock_port;
 828                 oplock_request = LEVEL_II_OPLOCK;
 829                 set_file_oplock(fsp, oplock_request);
 830         } else {
 831                 port = 0;
 832                 oplock_request = 0;
 833         }
 834
 835         set_share_mode(fsp, port, oplock_request);
 836
 837         unlock_share_entry_fsp(fsp);
 838
 839         conn->num_files_open++;
 840
 841         return fsp;
 842 }
 843
 844 /****************************************************************************
 845  Open a file for permissions read only. Return a pseudo file entry
 846  with the 'stat_open' flag set
 847 ****************************************************************************/
 848
 849 files_struct *open_file_stat(connection_struct *conn, char *fname,
 850                                                         SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
 851 {
 852         extern struct current_user current_user;
 853         files_struct *fsp = NULL;
 854
 855         if (!VALID_STAT(*psbuf)) {
 856                 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
 857                 return NULL;
 858         }
 859
 860         if(S_ISDIR(psbuf->st_mode)) {
 861                 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
 862                 return NULL;
 863         }
 864
 865         fsp = file_new();
 866         if(!fsp)
 867                 return NULL;
 868
 869         *action = FILE_WAS_OPENED;
 870
 871         DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
 872
 873         /*
 874          * Setup the files_struct for it.
 875          */
 876
 877         fsp->fd = -1;
 878         fsp->mode = psbuf->st_mode;
 879         fsp->inode = psbuf->st_ino;
 880         fsp->dev = psbuf->st_dev;
 881         GetTimeOfDay(&fsp->open_time);
 882         fsp->size = psbuf->st_size;
 883         fsp->vuid = current_user.vuid;
 884         fsp->pos = -1;
 885         fsp->can_lock = False;
 886         fsp->can_read = False;
 887         fsp->can_write = False;
 888         fsp->share_mode = 0;
 889         fsp->print_file = False;
 890         fsp->modified = False;
 891         fsp->oplock_type = NO_OPLOCK;
 892         fsp->sent_oplock_break = NO_BREAK_SENT;
 893         fsp->is_directory = False;
 894         fsp->stat_open = True;
 895         fsp->directory_delete_on_close = False;
 896         fsp->conn = conn;
 897         /*
 898          * Note that the file name here is the *untranslated* name
 899          * ie. it is still in the DOS codepage sent from the client.
 900          * All use of this filename will pass though the sys_xxxx
 901          * functions which will do the dos_to_unix translation before
 902          * mapping into a UNIX filename. JRA.
 903          */
 904         string_set(&fsp->fsp_name,fname);
 905         fsp->wbmpx_ptr = NULL;
 906     fsp->wcp = NULL; /* Write cache pointer. */
 907
 908         conn->num_files_open++;
 909
 910         return fsp;
 911 }
 912
 913 /****************************************************************************
 914  Open a directory from an NT SMB call.
 915 ****************************************************************************/
 916
 917 files_struct *open_directory(connection_struct *conn, char *fname,
 918                                                         SMB_STRUCT_STAT *psbuf, int smb_ofun, mode_t unixmode, int *action)
 919 {
 920         extern struct current_user current_user;
 921         BOOL got_stat = False;
 922         files_struct *fsp = file_new();
 923
 924         if(!fsp)
 925                 return NULL;
 926
 927         fsp->conn = conn; /* THe vfs_fXXX() macros need this. */
 928
 929         if (VALID_STAT(*psbuf))
 930                 got_stat = True;
 931
 932         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
 933                 file_free(fsp);
 934                 errno = EEXIST; /* Setup so correct error is returned to client. */
 935                 return NULL;
 936         }
 937
 938         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
 939
 940                 if (got_stat) {
 941
 942                         if(!S_ISDIR(psbuf->st_mode)) {
 943                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
 944                                 file_free(fsp);
 945                                 errno = EACCES;
 946                                 return NULL;
 947                         }
 948                         *action = FILE_WAS_OPENED;
 949
 950                 } else {
 951
 952                         /*
 953                          * Try and create the directory.
 954                          */
 955
 956                         if(!CAN_WRITE(conn)) {
 957                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
 958                                 file_free(fsp);
 959                                 errno = EACCES;
 960                                 return NULL;
 961                         }
 962
 963                         if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
 964                                 DEBUG(0,("open_directory: unable to create %s. Error was %s\n",
 965                                          fname, strerror(errno) ));
 966                                 file_free(fsp);
 967                                 return NULL;
 968                         }
 969
 970                         if(vfs_stat(conn,fname, psbuf) != 0) {
 971                                 file_free(fsp);
 972                                 return NULL;
 973                         }
 974
 975                         *action = FILE_WAS_CREATED;
 976
 977                 }
 978         } else {
 979
 980                 /*
 981                  * Don't create - just check that it *was* a directory.
 982                  */
 983
 984                 if(!got_stat) {
 985                         DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
 986                                  fname, strerror(errno) ));
 987                         file_free(fsp);
 988                         return NULL;
 989                 }
 990
 991                 if(!S_ISDIR(psbuf->st_mode)) {
 992                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
 993                         file_free(fsp);
 994                         return NULL;
 995                 }
 996
 997                 *action = FILE_WAS_OPENED;
 998         }
 999
1000         DEBUG(5,("open_directory: opening directory %s\n", fname));
1001
1002         /*
1003          * Setup the files_struct for it.
1004          */
1005
1006         fsp->fd = -1;
1007         fsp->mode = psbuf->st_mode;
1008         fsp->inode = psbuf->st_ino;
1009         fsp->dev = psbuf->st_dev;
1010         GetTimeOfDay(&fsp->open_time);
1011         fsp->size = psbuf->st_size;
1012         fsp->vuid = current_user.vuid;
1013         fsp->pos = -1;
1014         fsp->can_lock = True;
1015         fsp->can_read = False;
1016         fsp->can_write = False;
1017         fsp->share_mode = 0;
1018         fsp->print_file = False;
1019         fsp->modified = False;
1020         fsp->oplock_type = NO_OPLOCK;
1021         fsp->sent_oplock_break = NO_BREAK_SENT;
1022         fsp->is_directory = True;
1023         fsp->directory_delete_on_close = False;
1024         fsp->conn = conn;
1025         /*
1026          * Note that the file name here is the *untranslated* name
1027          * ie. it is still in the DOS codepage sent from the client.
1028          * All use of this filename will pass though the sys_xxxx
1029          * functions which will do the dos_to_unix translation before
1030          * mapping into a UNIX filename. JRA.
1031          */
1032         string_set(&fsp->fsp_name,fname);
1033         fsp->wbmpx_ptr = NULL;
1034
1035         conn->num_files_open++;
1036
1037         return fsp;
1038 }
1039
1040 /*******************************************************************
1041  Check if the share mode on a file allows it to be deleted or unlinked.
1042  Return True if sharing doesn't prevent the operation.
1043 ********************************************************************/
1044
1045 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1046 {
1047   int i;
1048   int ret = False;
1049   share_mode_entry *old_shares = 0;
1050   int num_share_modes;
1051   SMB_STRUCT_STAT sbuf;
1052   pid_t pid = sys_getpid();
1053   SMB_DEV_T dev;
1054   SMB_INO_T inode;
1055
1056   if (vfs_stat(conn,fname,&sbuf) == -1)
1057     return(True);
1058
1059   dev = sbuf.st_dev;
1060   inode = sbuf.st_ino;
1061
1062   lock_share_entry(conn, dev, inode);
1063   num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1064
1065   /*
1066    * Check if the share modes will give us access.
1067    */
1068
1069   if(num_share_modes != 0)
1070   {
1071     BOOL broke_oplock;
1072
1073     do
1074     {
1075
1076       broke_oplock = False;
1077       for(i = 0; i < num_share_modes; i++)
1078       {
1079         share_mode_entry *share_entry = &old_shares[i];
1080
1081         /*
1082          * Break oplocks before checking share modes. See comment in
1083          * open_file_shared for details.
1084          * Check if someone has an oplock on this file. If so we must
1085          * break it before continuing.
1086          */
1087         if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1088         {
1089
1090 #if 0
1091
1092 /* JRA. Try removing this code to see if the new oplock changes
1093    fix the problem. I'm dubious, but Andrew is recommending we
1094    try this....
1095 */
1096
1097           /*
1098            * It appears that the NT redirector may have a bug, in that
1099            * it tries to do an SMBmv on a file that it has open with a
1100            * batch oplock, and then fails to respond to the oplock break
1101            * request. This only seems to occur when the client is doing an
1102            * SMBmv to the smbd it is using - thus we try and detect this
1103            * condition by checking if the file being moved is open and oplocked by
1104            * this smbd process, and then not sending the oplock break in this
1105            * special case. If the file was open with a deny mode that
1106            * prevents the move the SMBmv will fail anyway with a share
1107            * violation error. JRA.
1108            */
1109           if(rename_op && (share_entry->pid == pid))
1110           {
1111
1112             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1113 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1114
1115             /*
1116              * This next line is a test that allows the deny-mode
1117              * processing to be skipped. This seems to be needed as
1118              * NT insists on the rename succeeding (in Office 9x no less !).
1119              * This should be removed as soon as (a) MS fix the redirector
1120              * bug or (b) NT SMB support in Samba makes NT not issue the
1121              * call (as is my fervent hope). JRA.
1122              */
1123             continue;
1124           }
1125           else
1126 #endif /* 0 */
1127           {
1128
1129             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1130 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1131
1132             /* Oplock break.... */
1133             unlock_share_entry(conn, dev, inode);
1134             if(request_oplock_break(share_entry, dev, inode) == False)
1135             {
1136               free((char *)old_shares);
1137
1138               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1139 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1140
1141               return False;
1142             }
1143             lock_share_entry(conn, dev, inode);
1144             broke_oplock = True;
1145             break;
1146           }
1147         }
1148
1149         /*
1150          * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1151          * this to proceed. This takes precedence over share modes.
1152          */
1153
1154         if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1155           continue;
1156
1157         /*
1158          * Someone else has a share lock on it, check to see
1159          * if we can too.
1160          */
1161
1162         if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1163             (share_entry->pid != pid))
1164           goto free_and_exit;
1165
1166       } /* end for */
1167
1168       if(broke_oplock)
1169       {
1170         free((char *)old_shares);
1171         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1172       }
1173     } while(broke_oplock);
1174   }
1175
1176   /* XXXX exactly what share mode combinations should be allowed for
1177      deleting/renaming? */
1178   /*
1179    * If we got here then either there were no share modes or
1180    * all share modes were DENY_DOS and the pid == getpid() or
1181    * delete access was requested and all share modes had the
1182    * ALLOW_SHARE_DELETE bit set (takes precedence over other
1183    * share modes).
1184    */
1185
1186   ret = True;
1187
1188 free_and_exit:
1189
1190   unlock_share_entry(conn, dev, inode);
1191   if(old_shares != NULL)
1192     free((char *)old_shares);
1193   return(ret);
1194 }