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