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