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