source/smbd/open.c

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