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 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_attempt_open(char *fname, int flags, mode_t mode)
  35 {
  36   int fd = dos_open(fname,flags,mode);
  37
  38   /* Fix for files ending in '.' */
  39   if((fd == -1) && (errno == ENOENT) &&
  40      (strchr(fname,'.')==NULL))
  41     {
  42       pstrcat(fname,".");
  43       fd = dos_open(fname,flags,mode);
  44     }
  45
  46 #if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF))
  47   if ((fd == -1) && (errno == ENAMETOOLONG))
  48     {
  49       int max_len;
  50       char *p = strrchr(fname, '/');
  51
  52       if (p == fname)   /* name is "/xxx" */
  53         {
  54           max_len = pathconf("/", _PC_NAME_MAX);
  55           p++;
  56         }
  57       else if ((p == NULL) || (p == fname))
  58         {
  59           p = fname;
  60           max_len = pathconf(".", _PC_NAME_MAX);
  61         }
  62       else
  63         {
  64           *p = '\0';
  65           max_len = pathconf(fname, _PC_NAME_MAX);
  66           *p = '/';
  67           p++;
  68         }
  69       if (strlen(p) > max_len)
  70         {
  71           char tmp = p[max_len];
  72
  73           p[max_len] = '\0';
  74           if ((fd = dos_open(fname,flags,mode)) == -1)
  75             p[max_len] = tmp;
  76         }
  77     }
  78 #endif
  79   return fd;
  80 }
  81
  82 /****************************************************************************
  83 Cache a uid_t currently with this file open. This is an optimization only
  84 used when multiple sessionsetup's have been done to one smbd.
  85 ****************************************************************************/
  86
  87 void fd_add_to_uid_cache(file_fd_struct *fd_ptr, uid_t u)
  88 {
  89   if(fd_ptr->uid_cache_count >= sizeof(fd_ptr->uid_users_cache)/sizeof(uid_t))
  90     return;
  91   fd_ptr->uid_users_cache[fd_ptr->uid_cache_count++] = u;
  92 }
  93
  94 /****************************************************************************
  95 Remove a uid_t that currently has this file open. This is an optimization only
  96 used when multiple sessionsetup's have been done to one smbd.
  97 ****************************************************************************/
  98
  99 static void fd_remove_from_uid_cache(file_fd_struct *fd_ptr, uid_t u)
 100 {
 101   int i;
 102   for(i = 0; i < fd_ptr->uid_cache_count; i++)
 103     if(fd_ptr->uid_users_cache[i] == u) {
 104       if(i < (fd_ptr->uid_cache_count-1))
 105         memmove((char *)&fd_ptr->uid_users_cache[i], (char *)&fd_ptr->uid_users_cache[i+1],
 106                sizeof(uid_t)*(fd_ptr->uid_cache_count-1-i) );
 107       fd_ptr->uid_cache_count--;
 108     }
 109   return;
 110 }
 111
 112 /****************************************************************************
 113 Check if a uid_t that currently has this file open is present. This is an
 114 optimization only used when multiple sessionsetup's have been done to one smbd.
 115 ****************************************************************************/
 116
 117 static BOOL fd_is_in_uid_cache(file_fd_struct *fd_ptr, uid_t u)
 118 {
 119   int i;
 120   for(i = 0; i < fd_ptr->uid_cache_count; i++)
 121     if(fd_ptr->uid_users_cache[i] == u)
 122       return True;
 123   return False;
 124 }
 125
 126 /****************************************************************************
 127 fd support routines - attempt to re-open an already open fd as O_RDWR.
 128 Save the already open fd (we cannot close due to POSIX file locking braindamage.
 129 ****************************************************************************/
 130
 131 static void fd_attempt_reopen(char *fname, mode_t mode, file_fd_struct *fd_ptr)
 132 {
 133   int fd = dos_open( fname, O_RDWR, mode);
 134
 135   if(fd == -1)
 136     return;
 137
 138   if(fd_ptr->real_open_flags == O_RDONLY)
 139     fd_ptr->fd_readonly = fd_ptr->fd;
 140   if(fd_ptr->real_open_flags == O_WRONLY)
 141     fd_ptr->fd_writeonly = fd_ptr->fd;
 142
 143   fd_ptr->fd = fd;
 144   fd_ptr->real_open_flags = O_RDWR;
 145 }
 146
 147 /****************************************************************************
 148 fd support routines - attempt to close the file referenced by this fd.
 149 Decrements the ref_count and returns it.
 150 ****************************************************************************/
 151
 152 uint16 fd_attempt_close(file_fd_struct *fd_ptr, int *err_ret)
 153 {
 154   extern struct current_user current_user;
 155   uint16 ret_ref = fd_ptr->ref_count;
 156
 157   *err_ret = 0;
 158
 159   DEBUG(3,("fd_attempt_close fd = %d, dev = %x, inode = %.0f, open_flags = %d, ref_count = %d.\n",
 160           fd_ptr->fd, (unsigned int)fd_ptr->dev, (double)fd_ptr->inode,
 161           fd_ptr->real_open_flags,
 162           fd_ptr->ref_count));
 163
 164   SMB_ASSERT(fd_ptr->ref_count != 0);
 165
 166   fd_ptr->ref_count--;
 167   ret_ref = fd_ptr->ref_count;
 168
 169   if(fd_ptr->ref_count == 0) {
 170
 171     if(fd_ptr->fd != -1) {
 172       if(close(fd_ptr->fd) < 0)
 173         *err_ret = errno;
 174         }
 175
 176     if(fd_ptr->fd_readonly != -1) {
 177       if(close(fd_ptr->fd_readonly) < 0) {
 178         if(*err_ret == 0)
 179           *err_ret = errno;
 180       }
 181         }
 182
 183     if(fd_ptr->fd_writeonly != -1) {
 184       if( close(fd_ptr->fd_writeonly) < 0) {
 185         if(*err_ret == 0)
 186           *err_ret = errno;
 187       }
 188         }
 189
 190     /*
 191      * Delete this fd_ptr.
 192      */
 193     fd_ptr_free(fd_ptr);
 194   } else {
 195     fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
 196   }
 197
 198   return ret_ref;
 199 }
 200
 201 /****************************************************************************
 202 fd support routines - check that current user has permissions
 203 to open this file. Used when uid not found in optimization cache.
 204 This is really ugly code, as due to POSIX locking braindamage we must
 205 fork and then attempt to open the file, and return success or failure
 206 via an exit code.
 207 ****************************************************************************/
 208
 209 static BOOL check_access_allowed_for_current_user( char *fname, int accmode )
 210 {
 211   pid_t child_pid;
 212
 213   /*
 214    * We need to temporarily stop CatchChild from eating
 215    * SIGCLD signals as it also eats the exit status code. JRA.
 216    */
 217
 218   CatchChildLeaveStatus();
 219
 220   if((child_pid = fork()) < 0) {
 221     DEBUG(0,("check_access_allowed_for_current_user: fork failed.\n"));
 222     CatchChild();
 223     return False;
 224   }
 225
 226   if(child_pid) {
 227     /*
 228      * Parent.
 229      */
 230     pid_t wpid;
 231     int status_code;
 232
 233     while ((wpid = sys_waitpid(child_pid, &status_code, 0)) < 0) {
 234       if(errno == EINTR) {
 235         errno = 0;
 236         continue;
 237       }
 238       DEBUG(0,("check_access_allowed_for_current_user: The process \
 239 is no longer waiting ! Error = %s\n", strerror(errno) ));
 240       CatchChild();
 241       return(False);
 242     }
 243
 244         /*
 245          * Go back to ignoring children.
 246          */
 247         CatchChild();
 248
 249     if (child_pid != wpid) {
 250       DEBUG(0,("check_access_allowed_for_current_user: We were waiting for the wrong process ID\n"));
 251       return(False);
 252     }
 253 #if defined(WIFEXITED) && defined(WEXITSTATUS)
 254     if (WIFEXITED(status_code) == 0) {
 255       DEBUG(0,("check_access_allowed_for_current_user: The process exited while we were waiting\n"));
 256       return(False);
 257     }
 258     if (WEXITSTATUS(status_code) != 0) {
 259       DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access denied.\n", status_code));
 260       return(False);
 261     }
 262 #else /* defined(WIFEXITED) && defined(WEXITSTATUS) */
 263     if(status_code != 0) {
 264       DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access denied.\n", status_code));
 265       return(False);
 266     }
 267 #endif /* defined(WIFEXITED) && defined(WEXITSTATUS) */
 268
 269     /*
 270      * Success - the child could open the file.
 271      */
 272     DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access allowed.\n", status_code));
 273     return True;
 274   } else {
 275     /*
 276      * Child.
 277      */
 278     int fd;
 279     DEBUG(9,("check_access_allowed_for_current_user: Child - attempting to open %s with mode %d.\n", fname, accmode ));
 280     if((fd = fd_attempt_open( fname, accmode, 0)) < 0) {
 281       /* Access denied. */
 282       _exit(EACCES);
 283     }
 284     close(fd);
 285     DEBUG(9,("check_access_allowed_for_current_user: Child - returning ok.\n"));
 286     _exit(0);
 287   }
 288
 289   return False;
 290 }
 291
 292 /****************************************************************************
 293 check a filename for the pipe string
 294 ****************************************************************************/
 295
 296 static void check_for_pipe(char *fname)
 297 {
 298         /* special case of pipe opens */
 299         char s[10];
 300         StrnCpy(s,fname,sizeof(s)-1);
 301         strlower(s);
 302         if (strstr(s,"pipe/")) {
 303                 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
 304                 unix_ERR_class = ERRSRV;
 305                 unix_ERR_code = ERRaccess;
 306         }
 307 }
 308
 309 /****************************************************************************
 310 open a file
 311 ****************************************************************************/
 312
 313 static void open_file(files_struct *fsp,connection_struct *conn,
 314                       char *fname1,int flags,mode_t mode, SMB_STRUCT_STAT *sbuf)
 315 {
 316   extern struct current_user current_user;
 317   pstring fname;
 318   SMB_STRUCT_STAT statbuf;
 319   file_fd_struct *fd_ptr;
 320   int accmode = (flags & O_ACCMODE);
 321
 322   fsp->open = False;
 323   fsp->fd_ptr = 0;
 324   fsp->oplock_type = NO_OPLOCK;
 325   errno = EPERM;
 326
 327   pstrcpy(fname,fname1);
 328
 329   /* check permissions */
 330
 331   /*
 332    * This code was changed after seeing a client open request
 333    * containing the open mode of (DENY_WRITE/read-only) with
 334    * the 'create if not exist' bit set. The previous code
 335    * would fail to open the file read only on a read-only share
 336    * as it was checking the flags parameter  directly against O_RDONLY,
 337    * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
 338    * JRA.
 339    */
 340
 341   if (!CAN_WRITE(conn) && !conn->printer) {
 342     /* It's a read-only share - fail if we wanted to write. */
 343     if(accmode != O_RDONLY) {
 344       DEBUG(3,("Permission denied opening %s\n",fname));
 345       check_for_pipe(fname);
 346       return;
 347     } else if(flags & O_CREAT) {
 348       /* We don't want to write - but we must make sure that O_CREAT
 349          doesn't create the file if we have write access into the
 350          directory.
 351        */
 352       flags &= ~O_CREAT;
 353     }
 354   }
 355
 356   /* this handles a bug in Win95 - it doesn't say to create the file when it
 357      should */
 358   if (conn->printer) {
 359           flags |= (O_CREAT|O_EXCL);
 360   }
 361
 362 /*
 363   if (flags == O_WRONLY)
 364     DEBUG(3,("Bug in client? Set O_WRONLY without O_CREAT\n"));
 365 */
 366
 367   /*
 368    * Ensure we have a valid struct stat so we can search the
 369    * open fd table.
 370    */
 371   if(sbuf == 0) {
 372     if(dos_stat(fname, &statbuf) < 0) {
 373       if(errno != ENOENT) {
 374         DEBUG(3,("Error doing stat on file %s (%s)\n",
 375                  fname,strerror(errno)));
 376
 377         check_for_pipe(fname);
 378         return;
 379       }
 380       sbuf = 0;
 381     } else {
 382       sbuf = &statbuf;
 383     }
 384   }
 385
 386   /*
 387    * Check to see if we have this file already
 388    * open. If we do, just use the already open fd and increment the
 389    * reference count (fd_get_already_open increments the ref_count).
 390    */
 391   if((fd_ptr = fd_get_already_open(sbuf))!= 0) {
 392     /*
 393      * File was already open.
 394      */
 395
 396     /*
 397      * Check it wasn't open for exclusive use.
 398      */
 399     if((flags & O_CREAT) && (flags & O_EXCL)) {
 400       fd_ptr->ref_count--;
 401       errno = EEXIST;
 402       return;
 403     }
 404
 405     /*
 406      * Ensure that the user attempting to open
 407      * this file has permissions to do so, if
 408      * the user who originally opened the file wasn't
 409      * the same as the current user.
 410      */
 411
 412     if(!fd_is_in_uid_cache(fd_ptr, (uid_t)current_user.uid)) {
 413       if(!check_access_allowed_for_current_user( fname, accmode )) {
 414         /* Error - permission denied. */
 415         DEBUG(3,("Permission denied opening file %s (flags=%d, accmode = %d)\n",
 416               fname, flags, accmode));
 417         /* Ensure the ref_count is decremented. */
 418         fd_ptr->ref_count--;
 419         fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
 420         errno = EACCES;
 421         return;
 422       }
 423     }
 424
 425     fd_add_to_uid_cache(fd_ptr, (uid_t)current_user.uid);
 426
 427     /*
 428      * If not opened O_RDWR try
 429      * and do that here - a chmod may have been done
 430      * between the last open and now.
 431      */
 432     if(fd_ptr->real_open_flags != O_RDWR)
 433       fd_attempt_reopen(fname, mode, fd_ptr);
 434
 435     /*
 436      * Ensure that if we wanted write access
 437      * it has been opened for write, and if we wanted read it
 438      * was open for read.
 439      */
 440     if(((accmode == O_WRONLY) && (fd_ptr->real_open_flags == O_RDONLY)) ||
 441        ((accmode == O_RDONLY) && (fd_ptr->real_open_flags == O_WRONLY)) ||
 442        ((accmode == O_RDWR) && (fd_ptr->real_open_flags != O_RDWR))) {
 443       DEBUG(3,("Error opening (already open for flags=%d) file %s (%s) (flags=%d)\n",
 444                fd_ptr->real_open_flags, fname,strerror(EACCES),flags));
 445       check_for_pipe(fname);
 446       fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
 447       fd_ptr->ref_count--;
 448       return;
 449     }
 450
 451   } else {
 452     int open_flags;
 453     /* We need to allocate a new file_fd_struct (this increments the
 454        ref_count). */
 455     if((fd_ptr = fd_get_new()) == 0)
 456       return;
 457     /*
 458      * Whatever the requested flags, attempt read/write access,
 459      * as we don't know what flags future file opens may require.
 460      * If this fails, try again with the required flags.
 461      * Even if we open read/write when only read access was
 462      * requested the setting of the can_write flag in
 463      * the file_struct will protect us from errant
 464      * write requests. We never need to worry about O_APPEND
 465      * as this is not set anywhere in Samba.
 466      */
 467     fd_ptr->real_open_flags = O_RDWR;
 468     /* Set the flags as needed without the read/write modes. */
 469     open_flags = flags & ~(O_RDWR|O_WRONLY|O_RDONLY);
 470     fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDWR, mode);
 471     /*
 472      * On some systems opening a file for R/W access on a read only
 473      * filesystems sets errno to EROFS.
 474      */
 475 #ifdef EROFS
 476     if((fd_ptr->fd == -1) && ((errno == EACCES) || (errno == EROFS))) {
 477 #else /* No EROFS */
 478     if((fd_ptr->fd == -1) && (errno == EACCES)) {
 479 #endif /* EROFS */
 480       if(accmode != O_RDWR) {
 481         fd_ptr->fd = fd_attempt_open(fname, open_flags|accmode, mode);
 482         fd_ptr->real_open_flags = accmode;
 483       }
 484     }
 485   }
 486
 487   if ((fd_ptr->fd >=0) &&
 488       conn->printer && lp_minprintspace(SNUM(conn))) {
 489     pstring dname;
 490     SMB_BIG_UINT dum1,dum2,dum3;
 491     char *p;
 492     pstrcpy(dname,fname);
 493     p = strrchr(dname,'/');
 494     if (p) *p = 0;
 495     if (sys_disk_free(dname,False,&dum1,&dum2,&dum3) < (SMB_BIG_UINT)lp_minprintspace(SNUM(conn))) {
 496       int err;
 497       if(fd_attempt_close(fd_ptr, &err) == 0)
 498         dos_unlink(fname);
 499       fsp->fd_ptr = 0;
 500       errno = ENOSPC;
 501       return;
 502     }
 503   }
 504
 505   if (fd_ptr->fd < 0)
 506   {
 507     int err;
 508     DEBUG(3,("Error opening file %s (%s) (flags=%d)\n",
 509       fname,strerror(errno),flags));
 510     /* Ensure the ref_count is decremented. */
 511     fd_attempt_close(fd_ptr,&err);
 512     check_for_pipe(fname);
 513     return;
 514   }
 515
 516   if (fd_ptr->fd >= 0)
 517   {
 518     if(sbuf == 0) {
 519       /* Do the fstat */
 520       if(sys_fstat(fd_ptr->fd, &statbuf) == -1) {
 521         int err;
 522         /* Error - backout !! */
 523         DEBUG(3,("Error doing fstat on fd %d, file %s (%s)\n",
 524                  fd_ptr->fd, fname,strerror(errno)));
 525         /* Ensure the ref_count is decremented. */
 526         fd_attempt_close(fd_ptr,&err);
 527         return;
 528       }
 529       sbuf = &statbuf;
 530     }
 531
 532     /* Set the correct entries in fd_ptr. */
 533     fd_ptr->dev = sbuf->st_dev;
 534     fd_ptr->inode = sbuf->st_ino;
 535
 536     fsp->fd_ptr = fd_ptr;
 537     conn->num_files_open++;
 538     fsp->mode = sbuf->st_mode;
 539     GetTimeOfDay(&fsp->open_time);
 540     fsp->vuid = current_user.vuid;
 541     fsp->size = 0;
 542     fsp->pos = -1;
 543     fsp->open = True;
 544     fsp->can_lock = True;
 545     fsp->can_read = ((flags & O_WRONLY)==0);
 546     fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
 547     fsp->share_mode = 0;
 548     fsp->print_file = conn->printer;
 549     fsp->modified = False;
 550     fsp->oplock_type = NO_OPLOCK;
 551     fsp->sent_oplock_break = NO_BREAK_SENT;
 552     fsp->is_directory = False;
 553     fsp->stat_open = False;
 554     fsp->directory_delete_on_close = False;
 555     fsp->conn = conn;
 556     /*
 557      * Note that the file name here is the *untranslated* name
 558      * ie. it is still in the DOS codepage sent from the client.
 559      * All use of this filename will pass though the sys_xxxx
 560      * functions which will do the dos_to_unix translation before
 561      * mapping into a UNIX filename. JRA.
 562      */
 563     string_set(&fsp->fsp_name,fname);
 564     fsp->wbmpx_ptr = NULL;
 565     fsp->wcp = NULL; /* Write cache pointer. */
 566
 567     /*
 568      * If the printer is marked as postscript output a leading
 569      * file identifier to ensure the file is treated as a raw
 570      * postscript file.
 571      * This has a similar effect as CtrlD=0 in WIN.INI file.
 572      * tim@fsg.com 09/06/94
 573      */
 574     if (fsp->print_file && lp_postscript(SNUM(conn)) && fsp->can_write) {
 575             DEBUG(3,("Writing postscript line\n"));
 576             write_file(fsp,"%!\n",-1,3);
 577     }
 578
 579     DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
 580              *sesssetup_user ? sesssetup_user : conn->user,fsp->fsp_name,
 581              BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
 582              conn->num_files_open));
 583
 584   }
 585 }
 586
 587 /****************************************************************************
 588   C. Hoch 11/22/95
 589   Helper for open_file_shared.
 590   Truncate a file after checking locking; close file if locked.
 591   **************************************************************************/
 592
 593 static void truncate_unless_locked(files_struct *fsp, connection_struct *conn, int token,
 594                                    BOOL *share_locked)
 595 {
 596         if (fsp->can_write){
 597                 SMB_OFF_T mask2 = ((SMB_OFF_T)0x3) << (SMB_OFF_T_BITS-4);
 598                 SMB_OFF_T mask = (mask2<<2);
 599
 600                 if (is_locked(fsp,conn,~mask,0,WRITE_LOCK)){
 601                         /* If share modes are in force for this connection we
 602                            have the share entry locked. Unlock it before closing. */
 603                         if (*share_locked && lp_share_modes(SNUM(conn)))
 604                                 unlock_share_entry( conn, fsp->fd_ptr->dev,
 605                                                     fsp->fd_ptr->inode);
 606                         close_file(fsp,False);
 607                         /* Share mode no longer locked. */
 608                         *share_locked = False;
 609                         errno = EACCES;
 610                         unix_ERR_class = ERRDOS;
 611                   unix_ERR_code = ERRlock;
 612                 } else {
 613                         sys_ftruncate(fsp->fd_ptr->fd,0);
 614                 }
 615         }
 616 }
 617
 618 enum {AFAIL,AREAD,AWRITE,AALL};
 619
 620 /*******************************************************************
 621 reproduce the share mode access table
 622 ********************************************************************/
 623
 624 static int access_table(int new_deny,int old_deny,int old_mode,
 625                         pid_t share_pid,char *fname)
 626 {
 627   if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
 628
 629   if (new_deny == DENY_DOS || old_deny == DENY_DOS) {
 630     pid_t pid = getpid();
 631     if (old_deny == new_deny && share_pid == pid)
 632         return(AALL);
 633
 634     /* the new smbpub.zip spec says that if the file extension is
 635        .com, .dll, .exe or .sym then allow the open. I will force
 636        it to read-only as this seems sensible although the spec is
 637        a little unclear on this. */
 638     if ((fname = strrchr(fname,'.'))) {
 639       if (strequal(fname,".com") ||
 640           strequal(fname,".dll") ||
 641           strequal(fname,".exe") ||
 642           strequal(fname,".sym"))
 643         return(AALL);
 644     }
 645
 646     if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
 647     if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
 648
 649
 650     return(AFAIL);
 651   }
 652
 653   switch (new_deny)
 654     {
 655     case DENY_WRITE:
 656       if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
 657       if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
 658       if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
 659       return(AFAIL);
 660     case DENY_READ:
 661       if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
 662       if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
 663       if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
 664       return(AFAIL);
 665     case DENY_NONE:
 666       if (old_deny==DENY_WRITE) return(AREAD);
 667       if (old_deny==DENY_READ) return(AWRITE);
 668       if (old_deny==DENY_NONE) return(AALL);
 669       return(AFAIL);
 670     }
 671   return(AFAIL);
 672 }
 673
 674 /****************************************************************************
 675 check if we can open a file with a share mode
 676 ****************************************************************************/
 677
 678 static int check_share_mode( share_mode_entry *share, int deny_mode,
 679                              char *fname,
 680                              BOOL fcbopen, int *flags)
 681 {
 682   int old_open_mode = GET_OPEN_MODE(share->share_mode);
 683   int old_deny_mode = GET_DENY_MODE(share->share_mode);
 684
 685   /*
 686    * Don't allow any open once the delete on close flag has been
 687    * set.
 688    */
 689
 690   if(GET_DELETE_ON_CLOSE_FLAG(share->share_mode))
 691   {
 692     DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
 693           fname ));
 694     unix_ERR_class = ERRDOS;
 695     unix_ERR_code = ERRnoaccess;
 696     return False;
 697   }
 698
 699   if (old_deny_mode > 4 || old_open_mode > 2)
 700   {
 701     DEBUG(0,("Invalid share mode found (%d,%d,%d) on file %s\n",
 702                deny_mode,old_deny_mode,old_open_mode,fname));
 703
 704     unix_ERR_class = ERRDOS;
 705     unix_ERR_code = ERRbadshare;
 706
 707     return False;
 708   }
 709
 710   {
 711     int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
 712                                       share->pid,fname);
 713
 714     if ((access_allowed == AFAIL) ||
 715         (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
 716         (access_allowed == AREAD && *flags != O_RDONLY) ||
 717         (access_allowed == AWRITE && *flags != O_WRONLY))
 718     {
 719       DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
 720                 deny_mode,old_deny_mode,old_open_mode,
 721                 (int)share->pid,fname, fcbopen, *flags, access_allowed));
 722
 723       unix_ERR_class = ERRDOS;
 724       unix_ERR_code = ERRbadshare;
 725
 726       return False;
 727     }
 728
 729     if (access_allowed == AREAD)
 730       *flags = O_RDONLY;
 731
 732     if (access_allowed == AWRITE)
 733       *flags = O_WRONLY;
 734
 735   }
 736
 737   return True;
 738 }
 739
 740 /****************************************************************************
 741 open a file with a share mode
 742 ****************************************************************************/
 743
 744 void open_file_shared(files_struct *fsp,connection_struct *conn,char *fname,int share_mode,int ofun,
 745                       mode_t mode,int oplock_request, int *Access,int *action)
 746 {
 747   int flags=0;
 748   int flags2=0;
 749   int deny_mode = GET_DENY_MODE(share_mode);
 750   BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
 751   SMB_STRUCT_STAT sbuf;
 752   BOOL file_existed = dos_file_exist(fname,&sbuf);
 753   BOOL share_locked = False;
 754   BOOL fcbopen = False;
 755   int token = 0;
 756   SMB_DEV_T dev = 0;
 757   SMB_INO_T inode = 0;
 758   int num_share_modes = 0;
 759   int oplock_contention_count = 0;
 760   BOOL all_current_opens_are_level_II = False;
 761   fsp->open = False;
 762   fsp->fd_ptr = 0;
 763
 764   DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
 765         fname, share_mode, ofun, (int)mode,  oplock_request ));
 766
 767
 768   /* ignore any oplock requests if oplocks are disabled */
 769   if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
 770           oplock_request = 0;
 771   }
 772
 773   /* this is for OS/2 EAs - try and say we don't support them */
 774   if (strstr(fname,".+,;=[]."))
 775   {
 776     unix_ERR_class = ERRDOS;
 777     /* OS/2 Workplace shell fix may be main code stream in a later release. */
 778 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
 779     unix_ERR_code = ERRcannotopen;
 780 #else /* OS2_WPS_FIX */
 781     unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
 782 #endif /* OS2_WPS_FIX */
 783
 784     DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
 785     return;
 786   }
 787
 788   if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)
 789   {
 790     DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
 791           fname ));
 792     errno = EEXIST;
 793     return;
 794   }
 795
 796   if (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST)
 797     flags2 |= O_CREAT;
 798
 799   if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)
 800     flags2 |= O_TRUNC;
 801
 802   if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
 803     flags2 |= O_EXCL;
 804
 805   /* note that we ignore the append flag as
 806      append does not mean the same thing under dos and unix */
 807
 808   switch (GET_OPEN_MODE(share_mode))
 809   {
 810     case DOS_OPEN_WRONLY:
 811       flags = O_WRONLY;
 812       break;
 813     case DOS_OPEN_FCB:
 814       fcbopen = True;
 815       flags = O_RDWR;
 816       break;
 817     case DOS_OPEN_RDWR:
 818       flags = O_RDWR;
 819       break;
 820     default:
 821       flags = O_RDONLY;
 822       break;
 823   }
 824
 825 #if defined(O_SYNC)
 826   if (GET_FILE_SYNC_OPENMODE(share_mode)) {
 827           flags2 |= O_SYNC;
 828   }
 829 #endif /* O_SYNC */
 830
 831   if (flags != O_RDONLY && file_existed &&
 832       (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,&sbuf))))
 833   {
 834     if (!fcbopen)
 835     {
 836       DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
 837             fname, !CAN_WRITE(conn) ? "share" : "file" ));
 838       errno = EACCES;
 839       return;
 840     }
 841     flags = O_RDONLY;
 842   }
 843
 844   if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB)
 845   {
 846     DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
 847     errno = EINVAL;
 848     return;
 849   }
 850
 851   if (deny_mode == DENY_FCB)
 852     deny_mode = DENY_DOS;
 853
 854   if (lp_share_modes(SNUM(conn)))
 855   {
 856     int i;
 857     share_mode_entry *old_shares = 0;
 858
 859     if (file_existed)
 860     {
 861       dev = sbuf.st_dev;
 862       inode = sbuf.st_ino;
 863       lock_share_entry(conn, dev, inode);
 864       share_locked = True;
 865       num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 866     }
 867
 868     /*
 869      * Check if the share modes will give us access.
 870      */
 871
 872     if(share_locked && (num_share_modes != 0))
 873     {
 874       BOOL broke_oplock;
 875
 876       do
 877       {
 878
 879         broke_oplock = False;
 880         all_current_opens_are_level_II = True;
 881
 882         for(i = 0; i < num_share_modes; i++)
 883         {
 884           share_mode_entry *share_entry = &old_shares[i];
 885
 886           /*
 887            * By observation of NetBench, oplocks are broken *before* share
 888            * modes are checked. This allows a file to be closed by the client
 889            * if the share mode would deny access and the client has an oplock.
 890            * Check if someone has an oplock on this file. If so we must break
 891            * it before continuing.
 892            */
 893           if((oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
 894              (!oplock_request && (share_entry->op_type != NO_OPLOCK)))
 895           {
 896
 897             DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
 898 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
 899
 900             /* Oplock break.... */
 901             unlock_share_entry(conn, dev, inode);
 902             if(request_oplock_break(share_entry, dev, inode) == False)
 903             {
 904               free((char *)old_shares);
 905
 906               DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
 907 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
 908
 909               errno = EACCES;
 910               unix_ERR_class = ERRDOS;
 911               unix_ERR_code = ERRbadshare;
 912               return;
 913             }
 914             lock_share_entry(conn, dev, inode);
 915             broke_oplock = True;
 916             all_current_opens_are_level_II = False;
 917             break;
 918           } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
 919             all_current_opens_are_level_II = False;
 920           }
 921
 922           /* someone else has a share lock on it, check to see
 923              if we can too */
 924           if(check_share_mode(share_entry, deny_mode, fname, fcbopen, &flags) == False)
 925           {
 926             free((char *)old_shares);
 927             unlock_share_entry(conn, dev, inode);
 928             errno = EACCES;
 929             return;
 930           }
 931
 932         } /* end for */
 933
 934         if(broke_oplock)
 935         {
 936           free((char *)old_shares);
 937           num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
 938           oplock_contention_count++;
 939         }
 940       } while(broke_oplock);
 941     }
 942
 943     if(old_shares != 0)
 944       free((char *)old_shares);
 945   }
 946
 947   /*
 948    * Refuse to grant an oplock in case the contention limit is
 949    * reached when going through the lock list multiple times.
 950    */
 951
 952   if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn)))
 953   {
 954     oplock_request = 0;
 955     DEBUG(4,("open_file_shared: oplock contention = %d. Not granting oplock.\n",
 956           oplock_contention_count ));
 957   }
 958
 959   DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
 960            flags,flags2,(int)mode));
 961
 962   open_file(fsp,conn,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0);
 963   if (!fsp->open && flags==O_RDWR && errno!=ENOENT && fcbopen)
 964   {
 965     flags = O_RDONLY;
 966     open_file(fsp,conn,fname,flags,mode,file_existed ? &sbuf : 0 );
 967   }
 968
 969   if (fsp->open)
 970   {
 971     int open_mode=0;
 972
 973     if((share_locked == False) && lp_share_modes(SNUM(conn)))
 974     {
 975       /* We created the file - thus we must now lock the share entry before creating it. */
 976       dev = fsp->fd_ptr->dev;
 977       inode = fsp->fd_ptr->inode;
 978       lock_share_entry(conn, dev, inode);
 979       share_locked = True;
 980     }
 981
 982     switch (flags)
 983     {
 984       case O_RDONLY:
 985         open_mode = DOS_OPEN_RDONLY;
 986         break;
 987       case O_RDWR:
 988         open_mode = DOS_OPEN_RDWR;
 989         break;
 990       case O_WRONLY:
 991         open_mode = DOS_OPEN_WRONLY;
 992         break;
 993     }
 994
 995     fsp->share_mode = SET_DENY_MODE(deny_mode) |
 996                       SET_OPEN_MODE(open_mode) |
 997                       SET_ALLOW_SHARE_DELETE(allow_share_delete);
 998
 999     if (Access)
1000       (*Access) = open_mode;
1001
1002     if (action)
1003     {
1004       if (file_existed && !(flags2 & O_TRUNC)) *action = FILE_WAS_OPENED;
1005       if (!file_existed) *action = FILE_WAS_CREATED;
1006       if (file_existed && (flags2 & O_TRUNC)) *action = FILE_WAS_OVERWRITTEN;
1007     }
1008     /* We must create the share mode entry before truncate as
1009        truncate can fail due to locking and have to close the
1010        file (which expects the share_mode_entry to be there).
1011      */
1012     if (lp_share_modes(SNUM(conn)))
1013     {
1014       uint16 port = 0;
1015
1016       /*
1017        * Setup the oplock info in both the shared memory and
1018        * file structs.
1019        */
1020
1021       if(oplock_request && (num_share_modes == 0) &&
1022               !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1023         port = global_oplock_port;
1024       } else if (oplock_request && all_current_opens_are_level_II) {
1025         port = global_oplock_port;
1026         oplock_request = LEVEL_II_OPLOCK;
1027         set_file_oplock(fsp, oplock_request);
1028       } else {
1029         port = 0;
1030         oplock_request = 0;
1031       }
1032
1033       set_share_mode(fsp, port, oplock_request);
1034     }
1035
1036     if ((flags2&O_TRUNC) && file_existed)
1037       truncate_unless_locked(fsp,conn,token,&share_locked);
1038   }
1039
1040   if (share_locked && lp_share_modes(SNUM(conn)))
1041     unlock_share_entry( conn, dev, inode);
1042 }
1043
1044 /****************************************************************************
1045  Open a file for permissions read only. Return a pseudo file entry
1046  with the 'stat_open' flag set and a fd_ptr of NULL.
1047 ****************************************************************************/
1048
1049 int open_file_stat(files_struct *fsp,connection_struct *conn,
1050                    char *fname, int smb_ofun, SMB_STRUCT_STAT *pst, int *action)
1051 {
1052         extern struct current_user current_user;
1053
1054         if(dos_stat(fname, pst) < 0) {
1055                 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n",
1056                          fname, strerror(errno) ));
1057                 return -1;
1058         }
1059
1060         if(S_ISDIR(pst->st_mode)) {
1061                 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
1062                 return -1;
1063         }
1064
1065         *action = FILE_WAS_OPENED;
1066
1067         DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
1068
1069         /*
1070          * Setup the files_struct for it.
1071          */
1072
1073         fsp->fd_ptr = NULL;
1074         conn->num_files_open++;
1075         fsp->mode = 0;
1076         GetTimeOfDay(&fsp->open_time);
1077         fsp->vuid = current_user.vuid;
1078         fsp->size = 0;
1079         fsp->pos = -1;
1080         fsp->open = True;
1081         fsp->can_lock = False;
1082         fsp->can_read = False;
1083         fsp->can_write = False;
1084         fsp->share_mode = 0;
1085         fsp->print_file = False;
1086         fsp->modified = False;
1087         fsp->oplock_type = NO_OPLOCK;
1088         fsp->sent_oplock_break = NO_BREAK_SENT;
1089         fsp->is_directory = False;
1090         fsp->stat_open = True;
1091         fsp->directory_delete_on_close = False;
1092         fsp->conn = conn;
1093         /*
1094          * Note that the file name here is the *untranslated* name
1095          * ie. it is still in the DOS codepage sent from the client.
1096          * All use of this filename will pass though the sys_xxxx
1097          * functions which will do the dos_to_unix translation before
1098          * mapping into a UNIX filename. JRA.
1099          */
1100         string_set(&fsp->fsp_name,fname);
1101         fsp->wbmpx_ptr = NULL;
1102     fsp->wcp = NULL; /* Write cache pointer. */
1103
1104         return 0;
1105 }
1106
1107 /****************************************************************************
1108  Open a directory from an NT SMB call.
1109 ****************************************************************************/
1110
1111 int open_directory(files_struct *fsp,connection_struct *conn,
1112                    char *fname, int smb_ofun, mode_t unixmode, int *action)
1113 {
1114         extern struct current_user current_user;
1115         SMB_STRUCT_STAT st;
1116         BOOL got_stat = False;
1117
1118         if(dos_stat(fname, &st) == 0) {
1119                 got_stat = True;
1120         }
1121
1122         if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1123                 errno = EEXIST; /* Setup so correct error is returned to client. */
1124                 return -1;
1125         }
1126
1127         if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1128
1129                 if (got_stat) {
1130
1131                         if(!S_ISDIR(st.st_mode)) {
1132                                 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1133                                 errno = EACCES;
1134                                 return -1;
1135                         }
1136                         *action = FILE_WAS_OPENED;
1137
1138                 } else {
1139
1140                         /*
1141                          * Try and create the directory.
1142                          */
1143
1144                         if(!CAN_WRITE(conn)) {
1145                                 DEBUG(2,("open_directory: failing create on read-only share\n"));
1146                                 errno = EACCES;
1147                                 return -1;
1148                         }
1149
1150                         if(dos_mkdir(fname, unix_mode(conn,aDIR, fname)) < 0) {
1151                                 DEBUG(0,("open_directory: unable to create %s. Error was %s\n",
1152                                          fname, strerror(errno) ));
1153                                 return -1;
1154                         }
1155                         *action = FILE_WAS_CREATED;
1156
1157                 }
1158         } else {
1159
1160                 /*
1161                  * Don't create - just check that it *was* a directory.
1162                  */
1163
1164                 if(!got_stat) {
1165                         DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1166                                  fname, strerror(errno) ));
1167                         return -1;
1168                 }
1169
1170                 if(!S_ISDIR(st.st_mode)) {
1171                         DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1172                         return -1;
1173                 }
1174
1175                 *action = FILE_WAS_OPENED;
1176         }
1177
1178         DEBUG(5,("open_directory: opening directory %s\n",
1179                  fname));
1180
1181         /*
1182          * Setup the files_struct for it.
1183          */
1184
1185         fsp->fd_ptr = NULL;
1186         conn->num_files_open++;
1187         fsp->mode = 0;
1188         GetTimeOfDay(&fsp->open_time);
1189         fsp->vuid = current_user.vuid;
1190         fsp->size = 0;
1191         fsp->pos = -1;
1192         fsp->open = True;
1193         fsp->can_lock = True;
1194         fsp->can_read = False;
1195         fsp->can_write = False;
1196         fsp->share_mode = 0;
1197         fsp->print_file = False;
1198         fsp->modified = False;
1199         fsp->oplock_type = NO_OPLOCK;
1200         fsp->sent_oplock_break = NO_BREAK_SENT;
1201         fsp->is_directory = True;
1202         fsp->directory_delete_on_close = False;
1203         fsp->conn = conn;
1204         /*
1205          * Note that the file name here is the *untranslated* name
1206          * ie. it is still in the DOS codepage sent from the client.
1207          * All use of this filename will pass though the sys_xxxx
1208          * functions which will do the dos_to_unix translation before
1209          * mapping into a UNIX filename. JRA.
1210          */
1211         string_set(&fsp->fsp_name,fname);
1212         fsp->wbmpx_ptr = NULL;
1213
1214         return 0;
1215 }
1216
1217 /*******************************************************************
1218  Check if the share mode on a file allows it to be deleted or unlinked.
1219  Return True if sharing doesn't prevent the operation.
1220 ********************************************************************/
1221
1222 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1223 {
1224   int i;
1225   int ret = False;
1226   share_mode_entry *old_shares = 0;
1227   int num_share_modes;
1228   SMB_STRUCT_STAT sbuf;
1229   pid_t pid = getpid();
1230   SMB_DEV_T dev;
1231   SMB_INO_T inode;
1232
1233   if(!lp_share_modes(SNUM(conn)))
1234     return True;
1235
1236   if (dos_stat(fname,&sbuf) == -1) return(True);
1237
1238   dev = sbuf.st_dev;
1239   inode = sbuf.st_ino;
1240
1241   lock_share_entry(conn, dev, inode);
1242   num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1243
1244   /*
1245    * Check if the share modes will give us access.
1246    */
1247
1248   if(num_share_modes != 0)
1249   {
1250     BOOL broke_oplock;
1251
1252     do
1253     {
1254
1255       broke_oplock = False;
1256       for(i = 0; i < num_share_modes; i++)
1257       {
1258         share_mode_entry *share_entry = &old_shares[i];
1259
1260         /*
1261          * Break oplocks before checking share modes. See comment in
1262          * open_file_shared for details.
1263          * Check if someone has an oplock on this file. If so we must
1264          * break it before continuing.
1265          */
1266         if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1267         {
1268
1269 #if 0
1270
1271 /* JRA. Try removing this code to see if the new oplock changes
1272    fix the problem. I'm dubious, but Andrew is recommending we
1273    try this....
1274 */
1275
1276           /*
1277            * It appears that the NT redirector may have a bug, in that
1278            * it tries to do an SMBmv on a file that it has open with a
1279            * batch oplock, and then fails to respond to the oplock break
1280            * request. This only seems to occur when the client is doing an
1281            * SMBmv to the smbd it is using - thus we try and detect this
1282            * condition by checking if the file being moved is open and oplocked by
1283            * this smbd process, and then not sending the oplock break in this
1284            * special case. If the file was open with a deny mode that
1285            * prevents the move the SMBmv will fail anyway with a share
1286            * violation error. JRA.
1287            */
1288           if(rename_op && (share_entry->pid == pid))
1289           {
1290
1291             DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1292 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1293
1294             /*
1295              * This next line is a test that allows the deny-mode
1296              * processing to be skipped. This seems to be needed as
1297              * NT insists on the rename succeeding (in Office 9x no less !).
1298              * This should be removed as soon as (a) MS fix the redirector
1299              * bug or (b) NT SMB support in Samba makes NT not issue the
1300              * call (as is my fervent hope). JRA.
1301              */
1302             continue;
1303           }
1304           else
1305 #endif /* 0 */
1306           {
1307
1308             DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1309 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1310
1311             /* Oplock break.... */
1312             unlock_share_entry(conn, dev, inode);
1313             if(request_oplock_break(share_entry, dev, inode) == False)
1314             {
1315               free((char *)old_shares);
1316
1317               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1318 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1319
1320               return False;
1321             }
1322             lock_share_entry(conn, dev, inode);
1323             broke_oplock = True;
1324             break;
1325           }
1326         }
1327
1328         /*
1329          * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1330          * this to proceed. This takes precedence over share modes.
1331          */
1332
1333         if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1334           continue;
1335
1336         /*
1337          * Someone else has a share lock on it, check to see
1338          * if we can too.
1339          */
1340
1341         if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) || (share_entry->pid != pid))
1342           goto free_and_exit;
1343
1344       } /* end for */
1345
1346       if(broke_oplock)
1347       {
1348         free((char *)old_shares);
1349         num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1350       }
1351     } while(broke_oplock);
1352   }
1353
1354   /* XXXX exactly what share mode combinations should be allowed for
1355      deleting/renaming? */
1356   /*
1357    * If we got here then either there were no share modes or
1358    * all share modes were DENY_DOS and the pid == getpid() or
1359    * delete access was requested and all share modes had the
1360    * ALLOW_SHARE_DELETE bit set (takes precedence over other
1361    * share modes).
1362    */
1363
1364   ret = True;
1365
1366 free_and_exit:
1367
1368   unlock_share_entry(conn, dev, inode);
1369   if(old_shares != NULL)
1370     free((char *)old_shares);
1371   return(ret);
1372 }