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