source/smbd/open.c

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