source3/smbd/open.c

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