r20257: Hey, change_owner_to_parent is now static :-)
[samba.git] / source3 / smbd / open.c
1 /* 
2    Unix SMB/CIFS implementation.
3    file opening and share modes
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Jeremy Allison 2001-2004
6    Copyright (C) Volker Lendecke 2005
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 struct generic_mapping file_generic_mapping;
26 extern struct current_user current_user;
27 extern userdom_struct current_user_info;
28 extern uint16 global_smbpid;
29 extern BOOL global_client_failed_oplock_break;
30
31 struct deferred_open_record {
32         BOOL delayed_for_oplocks;
33         SMB_DEV_T dev;
34         SMB_INO_T inode;
35 };
36
37 /****************************************************************************
38  fd support routines - attempt to do a dos_open.
39 ****************************************************************************/
40
41 static BOOL fd_open(struct connection_struct *conn,
42                     const char *fname, 
43                     files_struct *fsp,
44                     int flags,
45                     mode_t mode)
46 {
47         int sav;
48
49 #ifdef O_NOFOLLOW
50         if (!lp_symlinks(SNUM(conn))) {
51                 flags |= O_NOFOLLOW;
52         }
53 #endif
54
55         fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
56         sav = errno;
57
58         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
59                     fname, flags, (int)mode, fsp->fh->fd,
60                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
61
62         errno = sav;
63         return fsp->fh->fd != -1;
64 }
65
66 /****************************************************************************
67  Close the file associated with a fsp.
68 ****************************************************************************/
69
70 int fd_close(struct connection_struct *conn,
71              files_struct *fsp)
72 {
73         if (fsp->fh->fd == -1) {
74                 return 0; /* What we used to call a stat open. */
75         }
76         if (fsp->fh->ref_count > 1) {
77                 return 0; /* Shared handle. Only close last reference. */
78         }
79         return fd_close_posix(conn, fsp);
80 }
81
82 /****************************************************************************
83  Change the ownership of a file to that of the parent directory.
84  Do this by fd if possible.
85 ****************************************************************************/
86
87 static void change_owner_to_parent(connection_struct *conn,
88                                    files_struct *fsp,
89                                    const char *fname,
90                                    SMB_STRUCT_STAT *psbuf)
91 {
92         const char *parent_path = parent_dirname(fname);
93         SMB_STRUCT_STAT parent_st;
94         int ret;
95
96         ret = SMB_VFS_STAT(conn, parent_path, &parent_st);
97         if (ret == -1) {
98                 DEBUG(0,("change_owner_to_parent: failed to stat parent "
99                          "directory %s. Error was %s\n",
100                          parent_path, strerror(errno) ));
101                 return;
102         }
103
104         if (fsp && fsp->fh->fd != -1) {
105                 become_root();
106                 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
107                 unbecome_root();
108                 if (ret == -1) {
109                         DEBUG(0,("change_owner_to_parent: failed to fchown "
110                                  "file %s to parent directory uid %u. Error "
111                                  "was %s\n", fname,
112                                  (unsigned int)parent_st.st_uid,
113                                  strerror(errno) ));
114                 }
115
116                 DEBUG(10,("change_owner_to_parent: changed new file %s to "
117                           "parent directory uid %u.\n", fname,
118                           (unsigned int)parent_st.st_uid ));
119
120         } else {
121                 /* We've already done an lstat into psbuf, and we know it's a
122                    directory. If we can cd into the directory and the dev/ino
123                    are the same then we can safely chown without races as
124                    we're locking the directory in place by being in it.  This
125                    should work on any UNIX (thanks tridge :-). JRA.
126                 */
127
128                 pstring saved_dir;
129                 SMB_STRUCT_STAT sbuf;
130
131                 if (!vfs_GetWd(conn,saved_dir)) {
132                         DEBUG(0,("change_owner_to_parent: failed to get "
133                                  "current working directory\n"));
134                         return;
135                 }
136
137                 /* Chdir into the new path. */
138                 if (vfs_ChDir(conn, fname) == -1) {
139                         DEBUG(0,("change_owner_to_parent: failed to change "
140                                  "current working directory to %s. Error "
141                                  "was %s\n", fname, strerror(errno) ));
142                         goto out;
143                 }
144
145                 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
146                         DEBUG(0,("change_owner_to_parent: failed to stat "
147                                  "directory '.' (%s) Error was %s\n",
148                                  fname, strerror(errno)));
149                         goto out;
150                 }
151
152                 /* Ensure we're pointing at the same place. */
153                 if (sbuf.st_dev != psbuf->st_dev ||
154                     sbuf.st_ino != psbuf->st_ino ||
155                     sbuf.st_mode != psbuf->st_mode ) {
156                         DEBUG(0,("change_owner_to_parent: "
157                                  "device/inode/mode on directory %s changed. "
158                                  "Refusing to chown !\n", fname ));
159                         goto out;
160                 }
161
162                 become_root();
163                 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
164                 unbecome_root();
165                 if (ret == -1) {
166                         DEBUG(10,("change_owner_to_parent: failed to chown "
167                                   "directory %s to parent directory uid %u. "
168                                   "Error was %s\n", fname,
169                                   (unsigned int)parent_st.st_uid, strerror(errno) ));
170                         goto out;
171                 }
172
173                 DEBUG(10,("change_owner_to_parent: changed ownership of new "
174                           "directory %s to parent directory uid %u.\n",
175                           fname, (unsigned int)parent_st.st_uid ));
176
177   out:
178
179                 vfs_ChDir(conn,saved_dir);
180         }
181 }
182
183 /****************************************************************************
184  Open a file.
185 ****************************************************************************/
186
187 static NTSTATUS open_file(files_struct *fsp,
188                           connection_struct *conn,
189                           const char *fname,
190                           SMB_STRUCT_STAT *psbuf,
191                           int flags,
192                           mode_t unx_mode,
193                           uint32 access_mask, /* client requested access mask. */
194                           uint32 open_access_mask) /* what we're actually using in the open. */
195 {
196         int accmode = (flags & O_ACCMODE);
197         int local_flags = flags;
198         BOOL file_existed = VALID_STAT(*psbuf);
199
200         fsp->fh->fd = -1;
201         errno = EPERM;
202
203         /* Check permissions */
204
205         /*
206          * This code was changed after seeing a client open request 
207          * containing the open mode of (DENY_WRITE/read-only) with
208          * the 'create if not exist' bit set. The previous code
209          * would fail to open the file read only on a read-only share
210          * as it was checking the flags parameter  directly against O_RDONLY,
211          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
212          * JRA.
213          */
214
215         if (!CAN_WRITE(conn)) {
216                 /* It's a read-only share - fail if we wanted to write. */
217                 if(accmode != O_RDONLY) {
218                         DEBUG(3,("Permission denied opening %s\n",fname));
219                         return NT_STATUS_ACCESS_DENIED;
220                 } else if(flags & O_CREAT) {
221                         /* We don't want to write - but we must make sure that
222                            O_CREAT doesn't create the file if we have write
223                            access into the directory.
224                         */
225                         flags &= ~O_CREAT;
226                         local_flags &= ~O_CREAT;
227                 }
228         }
229
230         /*
231          * This little piece of insanity is inspired by the
232          * fact that an NT client can open a file for O_RDONLY,
233          * but set the create disposition to FILE_EXISTS_TRUNCATE.
234          * If the client *can* write to the file, then it expects to
235          * truncate the file, even though it is opening for readonly.
236          * Quicken uses this stupid trick in backup file creation...
237          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
238          * for helping track this one down. It didn't bite us in 2.0.x
239          * as we always opened files read-write in that release. JRA.
240          */
241
242         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
243                 DEBUG(10,("open_file: truncate requested on read-only open "
244                           "for file %s\n",fname ));
245                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
246         }
247
248         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
249             (!file_existed && (local_flags & O_CREAT)) ||
250             ((local_flags & O_TRUNC) == O_TRUNC) ) {
251
252                 /*
253                  * We can't actually truncate here as the file may be locked.
254                  * open_file_ntcreate will take care of the truncate later. JRA.
255                  */
256
257                 local_flags &= ~O_TRUNC;
258
259 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
260                 /*
261                  * We would block on opening a FIFO with no one else on the
262                  * other end. Do what we used to do and add O_NONBLOCK to the
263                  * open flags. JRA.
264                  */
265
266                 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
267                         local_flags |= O_NONBLOCK;
268                 }
269 #endif
270
271                 /* Don't create files with Microsoft wildcard characters. */
272                 if ((local_flags & O_CREAT) && !file_existed &&
273                     ms_has_wild(fname))  {
274                         return NT_STATUS_OBJECT_NAME_INVALID;
275                 }
276
277                 /* Actually do the open */
278                 if (!fd_open(conn, fname, fsp, local_flags, unx_mode)) {
279                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
280                                  "(flags=%d)\n",
281                                  fname,strerror(errno),local_flags,flags));
282                         return map_nt_error_from_unix(errno);
283                 }
284
285                 /* Inherit the ACL if the file was created. */
286                 if ((local_flags & O_CREAT)
287                     && !file_existed
288                     && lp_inherit_perms(SNUM(conn))) {
289                         inherit_access_acl(conn, fname, unx_mode);
290                 }
291
292         } else {
293                 fsp->fh->fd = -1; /* What we used to call a stat open. */
294         }
295
296         if (!file_existed) {
297                 int ret;
298
299                 if (fsp->fh->fd == -1) {
300                         ret = SMB_VFS_STAT(conn, fname, psbuf);
301                 } else {
302                         ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
303                         /* If we have an fd, this stat should succeed. */
304                         if (ret == -1) {
305                                 DEBUG(0,("Error doing fstat on open file %s "
306                                          "(%s)\n", fname,strerror(errno) ));
307                         }
308                 }
309
310                 /* For a non-io open, this stat failing means file not found. JRA */
311                 if (ret == -1) {
312                         NTSTATUS status = map_nt_error_from_unix(errno);
313                         fd_close(conn, fsp);
314                         return status;
315                 }
316         }
317
318         /*
319          * POSIX allows read-only opens of directories. We don't
320          * want to do this (we use a different code path for this)
321          * so catch a directory open and return an EISDIR. JRA.
322          */
323
324         if(S_ISDIR(psbuf->st_mode)) {
325                 fd_close(conn, fsp);
326                 errno = EISDIR;
327                 return NT_STATUS_FILE_IS_A_DIRECTORY;
328         }
329
330         fsp->mode = psbuf->st_mode;
331         fsp->inode = psbuf->st_ino;
332         fsp->dev = psbuf->st_dev;
333         fsp->vuid = current_user.vuid;
334         fsp->file_pid = global_smbpid;
335         fsp->can_lock = True;
336         fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
337         if (!CAN_WRITE(conn)) {
338                 fsp->can_write = False;
339         } else {
340                 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
341                         True : False;
342         }
343         fsp->print_file = False;
344         fsp->modified = False;
345         fsp->sent_oplock_break = NO_BREAK_SENT;
346         fsp->is_directory = False;
347         fsp->is_stat = False;
348         if (conn->aio_write_behind_list &&
349             is_in_path(fname, conn->aio_write_behind_list, conn->case_sensitive)) {
350                 fsp->aio_write_behind = True;
351         }
352
353         string_set(&fsp->fsp_name,fname);
354         fsp->wcp = NULL; /* Write cache pointer. */
355
356         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
357                  *current_user_info.smb_name ?
358                  current_user_info.smb_name : conn->user,fsp->fsp_name,
359                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
360                  conn->num_files_open + 1));
361
362         errno = 0;
363         return NT_STATUS_OK;
364 }
365
366 /*******************************************************************
367  Return True if the filename is one of the special executable types.
368 ********************************************************************/
369
370 static BOOL is_executable(const char *fname)
371 {
372         if ((fname = strrchr_m(fname,'.'))) {
373                 if (strequal(fname,".com") ||
374                     strequal(fname,".dll") ||
375                     strequal(fname,".exe") ||
376                     strequal(fname,".sym")) {
377                         return True;
378                 }
379         }
380         return False;
381 }
382
383 /****************************************************************************
384  Check if we can open a file with a share mode.
385  Returns True if conflict, False if not.
386 ****************************************************************************/
387
388 static BOOL share_conflict(struct share_mode_entry *entry,
389                            uint32 access_mask,
390                            uint32 share_access)
391 {
392         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
393                   "entry->share_access = 0x%x, "
394                   "entry->private_options = 0x%x\n",
395                   (unsigned int)entry->access_mask,
396                   (unsigned int)entry->share_access,
397                   (unsigned int)entry->private_options));
398
399         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
400                   (unsigned int)access_mask, (unsigned int)share_access));
401
402         if ((entry->access_mask & (FILE_WRITE_DATA|
403                                    FILE_APPEND_DATA|
404                                    FILE_READ_DATA|
405                                    FILE_EXECUTE|
406                                    DELETE_ACCESS)) == 0) {
407                 DEBUG(10,("share_conflict: No conflict due to "
408                           "entry->access_mask = 0x%x\n",
409                           (unsigned int)entry->access_mask ));
410                 return False;
411         }
412
413         if ((access_mask & (FILE_WRITE_DATA|
414                             FILE_APPEND_DATA|
415                             FILE_READ_DATA|
416                             FILE_EXECUTE|
417                             DELETE_ACCESS)) == 0) {
418                 DEBUG(10,("share_conflict: No conflict due to "
419                           "access_mask = 0x%x\n",
420                           (unsigned int)access_mask ));
421                 return False;
422         }
423
424 #if 1 /* JRA TEST - Superdebug. */
425 #define CHECK_MASK(num, am, right, sa, share) \
426         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
427                 (unsigned int)(num), (unsigned int)(am), \
428                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
429         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
430                 (unsigned int)(num), (unsigned int)(sa), \
431                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
432         if (((am) & (right)) && !((sa) & (share))) { \
433                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
434 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
435                         (unsigned int)(share) )); \
436                 return True; \
437         }
438 #else
439 #define CHECK_MASK(num, am, right, sa, share) \
440         if (((am) & (right)) && !((sa) & (share))) { \
441                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
442 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
443                         (unsigned int)(share) )); \
444                 return True; \
445         }
446 #endif
447
448         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
449                    share_access, FILE_SHARE_WRITE);
450         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
451                    entry->share_access, FILE_SHARE_WRITE);
452         
453         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
454                    share_access, FILE_SHARE_READ);
455         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
456                    entry->share_access, FILE_SHARE_READ);
457
458         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
459                    share_access, FILE_SHARE_DELETE);
460         CHECK_MASK(6, access_mask, DELETE_ACCESS,
461                    entry->share_access, FILE_SHARE_DELETE);
462
463         DEBUG(10,("share_conflict: No conflict.\n"));
464         return False;
465 }
466
467 #if defined(DEVELOPER)
468 static void validate_my_share_entries(int num,
469                                       struct share_mode_entry *share_entry)
470 {
471         files_struct *fsp;
472
473         if (!procid_is_me(&share_entry->pid)) {
474                 return;
475         }
476
477         if (is_deferred_open_entry(share_entry) &&
478             !open_was_deferred(share_entry->op_mid)) {
479                 pstring str;
480                 pstr_sprintf(str, "Got a deferred entry without a request: "
481                              "PANIC: %s\n", share_mode_str(num, share_entry));
482                 smb_panic(str);
483         }
484
485         if (!is_valid_share_mode_entry(share_entry)) {
486                 return;
487         }
488
489         fsp = file_find_dif(share_entry->dev, share_entry->inode,
490                             share_entry->share_file_id);
491         if (!fsp) {
492                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
493                          share_mode_str(num, share_entry) ));
494                 smb_panic("validate_my_share_entries: Cannot match a "
495                           "share entry with an open file\n");
496         }
497
498         if (is_deferred_open_entry(share_entry) ||
499             is_unused_share_mode_entry(share_entry)) {
500                 goto panic;
501         }
502
503         if ((share_entry->op_type == NO_OPLOCK) &&
504             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
505                 /* Someone has already written to it, but I haven't yet
506                  * noticed */
507                 return;
508         }
509
510         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
511                 goto panic;
512         }
513
514         return;
515
516  panic:
517         {
518                 pstring str;
519                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
520                          share_mode_str(num, share_entry) ));
521                 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
522                          "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
523                          fsp->fsp_name, (unsigned int)fsp->oplock_type,
524                          (unsigned int)share_entry->op_type );
525                 smb_panic(str);
526         }
527 }
528 #endif
529
530 static BOOL is_stat_open(uint32 access_mask)
531 {
532         return (access_mask &&
533                 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
534                                   FILE_WRITE_ATTRIBUTES))==0) &&
535                 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
536                                  FILE_WRITE_ATTRIBUTES)) != 0));
537 }
538
539 /****************************************************************************
540  Deal with share modes
541  Invarient: Share mode must be locked on entry and exit.
542  Returns -1 on error, or number of share modes on success (may be zero).
543 ****************************************************************************/
544
545 static NTSTATUS open_mode_check(connection_struct *conn,
546                                 const char *fname,
547                                 struct share_mode_lock *lck,
548                                 uint32 access_mask,
549                                 uint32 share_access,
550                                 uint32 create_options,
551                                 BOOL *file_existed)
552 {
553         int i;
554
555         if(lck->num_share_modes == 0) {
556                 return NT_STATUS_OK;
557         }
558
559         *file_existed = True;
560         
561         if (is_stat_open(access_mask)) {
562                 /* Stat open that doesn't trigger oplock breaks or share mode
563                  * checks... ! JRA. */
564                 return NT_STATUS_OK;
565         }
566
567         /* A delete on close prohibits everything */
568
569         if (lck->delete_on_close) {
570                 return NT_STATUS_DELETE_PENDING;
571         }
572
573         /*
574          * Check if the share modes will give us access.
575          */
576         
577 #if defined(DEVELOPER)
578         for(i = 0; i < lck->num_share_modes; i++) {
579                 validate_my_share_entries(i, &lck->share_modes[i]);
580         }
581 #endif
582
583         if (!lp_share_modes(SNUM(conn))) {
584                 return NT_STATUS_OK;
585         }
586
587         /* Now we check the share modes, after any oplock breaks. */
588         for(i = 0; i < lck->num_share_modes; i++) {
589
590                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
591                         continue;
592                 }
593
594                 /* someone else has a share lock on it, check to see if we can
595                  * too */
596                 if (share_conflict(&lck->share_modes[i],
597                                    access_mask, share_access)) {
598                         return NT_STATUS_SHARING_VIOLATION;
599                 }
600         }
601         
602         return NT_STATUS_OK;
603 }
604
605 static BOOL is_delete_request(files_struct *fsp) {
606         return ((fsp->access_mask == DELETE_ACCESS) &&
607                 (fsp->oplock_type == NO_OPLOCK));
608 }
609
610 /*
611  * 1) No files open at all or internal open: Grant whatever the client wants.
612  *
613  * 2) Exclusive (or batch) oplock around: If the requested access is a delete
614  *    request, break if the oplock around is a batch oplock. If it's another
615  *    requested access type, break.
616  * 
617  * 3) Only level2 around: Grant level2 and do nothing else.
618  */
619
620 static BOOL delay_for_oplocks(struct share_mode_lock *lck,
621                               files_struct *fsp,
622                               int pass_number,
623                               int oplock_request)
624 {
625         int i;
626         struct share_mode_entry *exclusive = NULL;
627         BOOL valid_entry = False;
628         BOOL delay_it = False;
629         BOOL have_level2 = False;
630         BOOL ret;
631         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
632
633         if (oplock_request & INTERNAL_OPEN_ONLY) {
634                 fsp->oplock_type = NO_OPLOCK;
635         }
636
637         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
638                 return False;
639         }
640
641         for (i=0; i<lck->num_share_modes; i++) {
642
643                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
644                         continue;
645                 }
646
647                 /* At least one entry is not an invalid or deferred entry. */
648                 valid_entry = True;
649
650                 if (pass_number == 1) {
651                         if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
652                                 SMB_ASSERT(exclusive == NULL);                  
653                                 exclusive = &lck->share_modes[i];
654                         }
655                 } else {
656                         if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
657                                 SMB_ASSERT(exclusive == NULL);                  
658                                 exclusive = &lck->share_modes[i];
659                         }
660                 }
661
662                 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
663                         SMB_ASSERT(exclusive == NULL);                  
664                         have_level2 = True;
665                 }
666         }
667
668         if (!valid_entry) {
669                 /* All entries are placeholders or deferred.
670                  * Directly grant whatever the client wants. */
671                 if (fsp->oplock_type == NO_OPLOCK) {
672                         /* Store a level2 oplock, but don't tell the client */
673                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
674                 }
675                 return False;
676         }
677
678         if (exclusive != NULL) { /* Found an exclusive oplock */
679                 SMB_ASSERT(!have_level2);
680                 delay_it = is_delete_request(fsp) ?
681                         BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
682         }
683
684         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
685                 /* We can at most grant level2 as there are other
686                  * level2 or NO_OPLOCK entries. */
687                 fsp->oplock_type = LEVEL_II_OPLOCK;
688         }
689
690         if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
691                 /* Store a level2 oplock, but don't tell the client */
692                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
693         }
694
695         if (!delay_it) {
696                 return False;
697         }
698
699         /*
700          * Send a break message to the oplock holder and delay the open for
701          * our client.
702          */
703
704         DEBUG(10, ("Sending break request to PID %s\n",
705                    procid_str_static(&exclusive->pid)));
706         exclusive->op_mid = get_current_mid();
707
708         /* Create the message. */
709         share_mode_entry_to_message(msg, exclusive);
710
711         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
712            don't want this set in the share mode struct pointed to by lck. */
713
714         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
715                 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
716         }
717
718         ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
719                                msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
720         if (!ret) {
721                 DEBUG(3, ("Could not send oplock break message\n"));
722         }
723
724         return True;
725 }
726
727 static BOOL request_timed_out(struct timeval request_time,
728                               struct timeval timeout)
729 {
730         struct timeval now, end_time;
731         GetTimeOfDay(&now);
732         end_time = timeval_sum(&request_time, &timeout);
733         return (timeval_compare(&end_time, &now) < 0);
734 }
735
736 /****************************************************************************
737  Handle the 1 second delay in returning a SHARING_VIOLATION error.
738 ****************************************************************************/
739
740 static void defer_open(struct share_mode_lock *lck,
741                        struct timeval request_time,
742                        struct timeval timeout,
743                        struct deferred_open_record *state)
744 {
745         uint16 mid = get_current_mid();
746         int i;
747
748         /* Paranoia check */
749
750         for (i=0; i<lck->num_share_modes; i++) {
751                 struct share_mode_entry *e = &lck->share_modes[i];
752
753                 if (!is_deferred_open_entry(e)) {
754                         continue;
755                 }
756
757                 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
758                         DEBUG(0, ("Trying to defer an already deferred "
759                                   "request: mid=%d, exiting\n", mid));
760                         exit_server("attempt to defer a deferred request");
761                 }
762         }
763
764         /* End paranoia check */
765
766         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
767                   "open entry for mid %u\n",
768                   (unsigned int)request_time.tv_sec,
769                   (unsigned int)request_time.tv_usec,
770                   (unsigned int)mid));
771
772         if (!push_deferred_smb_message(mid, request_time, timeout,
773                                        (char *)state, sizeof(*state))) {
774                 exit_server("push_deferred_smb_message failed");
775         }
776         add_deferred_open(lck, mid, request_time, state->dev, state->inode);
777
778         /*
779          * Push the MID of this packet on the signing queue.
780          * We only do this once, the first time we push the packet
781          * onto the deferred open queue, as this has a side effect
782          * of incrementing the response sequence number.
783          */
784
785         srv_defer_sign_response(mid);
786 }
787
788
789 /****************************************************************************
790  On overwrite open ensure that the attributes match.
791 ****************************************************************************/
792
793 static BOOL open_match_attributes(connection_struct *conn,
794                                   const char *path,
795                                   uint32 old_dos_attr,
796                                   uint32 new_dos_attr,
797                                   mode_t existing_unx_mode,
798                                   mode_t new_unx_mode,
799                                   mode_t *returned_unx_mode)
800 {
801         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
802
803         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
804         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
805
806         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) || 
807            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
808                 *returned_unx_mode = new_unx_mode;
809         } else {
810                 *returned_unx_mode = (mode_t)0;
811         }
812
813         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
814                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
815                   "returned_unx_mode = 0%o\n",
816                   path,
817                   (unsigned int)old_dos_attr,
818                   (unsigned int)existing_unx_mode,
819                   (unsigned int)new_dos_attr,
820                   (unsigned int)*returned_unx_mode ));
821
822         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
823         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
824                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
825                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
826                         return False;
827                 }
828         }
829         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
830                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
831                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
832                         return False;
833                 }
834         }
835         return True;
836 }
837
838 /****************************************************************************
839  Special FCB or DOS processing in the case of a sharing violation.
840  Try and find a duplicated file handle.
841 ****************************************************************************/
842
843 static files_struct *fcb_or_dos_open(connection_struct *conn,
844                                      const char *fname, SMB_DEV_T dev,
845                                      SMB_INO_T inode,
846                                      uint32 access_mask,
847                                      uint32 share_access,
848                                      uint32 create_options)
849 {
850         files_struct *fsp;
851         files_struct *dup_fsp;
852
853         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
854                  "file %s.\n", fname ));
855
856         for(fsp = file_find_di_first(dev, inode); fsp;
857             fsp = file_find_di_next(fsp)) {
858
859                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
860                           "vuid = %u, file_pid = %u, private_options = 0x%x "
861                           "access_mask = 0x%x\n", fsp->fsp_name,
862                           fsp->fh->fd, (unsigned int)fsp->vuid,
863                           (unsigned int)fsp->file_pid,
864                           (unsigned int)fsp->fh->private_options,
865                           (unsigned int)fsp->access_mask ));
866
867                 if (fsp->fh->fd != -1 &&
868                     fsp->vuid == current_user.vuid &&
869                     fsp->file_pid == global_smbpid &&
870                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
871                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
872                     (fsp->access_mask & FILE_WRITE_DATA) &&
873                     strequal(fsp->fsp_name, fname)) {
874                         DEBUG(10,("fcb_or_dos_open: file match\n"));
875                         break;
876                 }
877         }
878
879         if (!fsp) {
880                 return NULL;
881         }
882
883         /* quite an insane set of semantics ... */
884         if (is_executable(fname) &&
885             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
886                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
887                 return NULL;
888         }
889
890         /* We need to duplicate this fsp. */
891         if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
892                                           create_options, &dup_fsp))) {
893                 return NULL;
894         }
895
896         return dup_fsp;
897 }
898
899 /****************************************************************************
900  Open a file with a share mode - old openX method - map into NTCreate.
901 ****************************************************************************/
902
903 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
904                                  uint32 *paccess_mask,
905                                  uint32 *pshare_mode,
906                                  uint32 *pcreate_disposition,
907                                  uint32 *pcreate_options)
908 {
909         uint32 access_mask;
910         uint32 share_mode;
911         uint32 create_disposition;
912         uint32 create_options = 0;
913
914         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
915                   "open_func = 0x%x\n",
916                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
917
918         /* Create the NT compatible access_mask. */
919         switch (GET_OPENX_MODE(deny_mode)) {
920                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
921                 case DOS_OPEN_RDONLY:
922                         access_mask = FILE_GENERIC_READ;
923                         break;
924                 case DOS_OPEN_WRONLY:
925                         access_mask = FILE_GENERIC_WRITE;
926                         break;
927                 case DOS_OPEN_RDWR:
928                 case DOS_OPEN_FCB:
929                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
930                         break;
931                 default:
932                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
933                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
934                         return False;
935         }
936
937         /* Create the NT compatible create_disposition. */
938         switch (open_func) {
939                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
940                         create_disposition = FILE_CREATE;
941                         break;
942
943                 case OPENX_FILE_EXISTS_OPEN:
944                         create_disposition = FILE_OPEN;
945                         break;
946
947                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
948                         create_disposition = FILE_OPEN_IF;
949                         break;
950        
951                 case OPENX_FILE_EXISTS_TRUNCATE:
952                         create_disposition = FILE_OVERWRITE;
953                         break;
954
955                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
956                         create_disposition = FILE_OVERWRITE_IF;
957                         break;
958
959                 default:
960                         /* From samba4 - to be confirmed. */
961                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
962                                 create_disposition = FILE_CREATE;
963                                 break;
964                         }
965                         DEBUG(10,("map_open_params_to_ntcreate: bad "
966                                   "open_func 0x%x\n", (unsigned int)open_func));
967                         return False;
968         }
969  
970         /* Create the NT compatible share modes. */
971         switch (GET_DENY_MODE(deny_mode)) {
972                 case DENY_ALL:
973                         share_mode = FILE_SHARE_NONE;
974                         break;
975
976                 case DENY_WRITE:
977                         share_mode = FILE_SHARE_READ;
978                         break;
979
980                 case DENY_READ:
981                         share_mode = FILE_SHARE_WRITE;
982                         break;
983
984                 case DENY_NONE:
985                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
986                         break;
987
988                 case DENY_DOS:
989                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
990                         if (is_executable(fname)) {
991                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
992                         } else {
993                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
994                                         share_mode = FILE_SHARE_READ;
995                                 } else {
996                                         share_mode = FILE_SHARE_NONE;
997                                 }
998                         }
999                         break;
1000
1001                 case DENY_FCB:
1002                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1003                         share_mode = FILE_SHARE_NONE;
1004                         break;
1005
1006                 default:
1007                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1008                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1009                         return False;
1010         }
1011
1012         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1013                   "share_mode = 0x%x, create_disposition = 0x%x, "
1014                   "create_options = 0x%x\n",
1015                   fname,
1016                   (unsigned int)access_mask,
1017                   (unsigned int)share_mode,
1018                   (unsigned int)create_disposition,
1019                   (unsigned int)create_options ));
1020
1021         if (paccess_mask) {
1022                 *paccess_mask = access_mask;
1023         }
1024         if (pshare_mode) {
1025                 *pshare_mode = share_mode;
1026         }
1027         if (pcreate_disposition) {
1028                 *pcreate_disposition = create_disposition;
1029         }
1030         if (pcreate_options) {
1031                 *pcreate_options = create_options;
1032         }
1033
1034         return True;
1035
1036 }
1037
1038 static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1039 {
1040         struct deferred_open_record state;
1041
1042         /* This is a relative time, added to the absolute
1043            request_time value to get the absolute timeout time.
1044            Note that if this is the second or greater time we enter
1045            this codepath for this particular request mid then
1046            request_time is left as the absolute time of the *first*
1047            time this request mid was processed. This is what allows
1048            the request to eventually time out. */
1049
1050         struct timeval timeout;
1051
1052         /* Normally the smbd we asked should respond within
1053          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1054          * the client did, give twice the timeout as a safety
1055          * measure here in case the other smbd is stuck
1056          * somewhere else. */
1057
1058         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1059
1060         /* Nothing actually uses state.delayed_for_oplocks
1061            but it's handy to differentiate in debug messages
1062            between a 30 second delay due to oplock break, and
1063            a 1 second delay for share mode conflicts. */
1064
1065         state.delayed_for_oplocks = True;
1066         state.dev = lck->dev;
1067         state.inode = lck->ino;
1068
1069         if (!request_timed_out(request_time, timeout)) {
1070                 defer_open(lck, request_time, timeout, &state);
1071         }
1072 }
1073
1074 /****************************************************************************
1075  Open a file with a share mode.
1076 ****************************************************************************/
1077
1078 NTSTATUS open_file_ntcreate(connection_struct *conn,
1079                             const char *fname,
1080                             SMB_STRUCT_STAT *psbuf,
1081                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1082                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1083                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1084                             uint32 create_options,      /* options such as delete on close. */
1085                             uint32 new_dos_attributes,  /* attributes used for new file. */
1086                             int oplock_request,         /* internal Samba oplock codes. */
1087                                                         /* Information (FILE_EXISTS etc.) */
1088                             int *pinfo,
1089                             files_struct **result)
1090 {
1091         int flags=0;
1092         int flags2=0;
1093         BOOL file_existed = VALID_STAT(*psbuf);
1094         BOOL def_acl = False;
1095         SMB_DEV_T dev = 0;
1096         SMB_INO_T inode = 0;
1097         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1098         files_struct *fsp = NULL;
1099         mode_t new_unx_mode = (mode_t)0;
1100         mode_t unx_mode = (mode_t)0;
1101         int info;
1102         uint32 existing_dos_attributes = 0;
1103         struct pending_message_list *pml = NULL;
1104         uint16 mid = get_current_mid();
1105         struct timeval request_time = timeval_zero();
1106         struct share_mode_lock *lck = NULL;
1107         uint32 open_access_mask = access_mask;
1108         NTSTATUS status;
1109         int ret_flock;
1110
1111         if (conn->printer) {
1112                 /* 
1113                  * Printers are handled completely differently.
1114                  * Most of the passed parameters are ignored.
1115                  */
1116
1117                 if (pinfo) {
1118                         *pinfo = FILE_WAS_CREATED;
1119                 }
1120
1121                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1122
1123                 return print_fsp_open(conn, fname, result);
1124         }
1125
1126         /* We add aARCH to this as this mode is only used if the file is
1127          * created new. */
1128         unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1129
1130         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1131                    "access_mask=0x%x share_access=0x%x "
1132                    "create_disposition = 0x%x create_options=0x%x "
1133                    "unix mode=0%o oplock_request=%d\n",
1134                    fname, new_dos_attributes, access_mask, share_access,
1135                    create_disposition, create_options, unx_mode,
1136                    oplock_request));
1137
1138         if ((pml = get_open_deferred_message(mid)) != NULL) {
1139                 struct deferred_open_record *state =
1140                         (struct deferred_open_record *)pml->private_data.data;
1141
1142                 /* Remember the absolute time of the original
1143                    request with this mid. We'll use it later to
1144                    see if this has timed out. */
1145
1146                 request_time = pml->request_time;
1147
1148                 /* Remove the deferred open entry under lock. */
1149                 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1150                 if (lck == NULL) {
1151                         DEBUG(0, ("could not get share mode lock\n"));
1152                 } else {
1153                         del_deferred_open_entry(lck, mid);
1154                         TALLOC_FREE(lck);
1155                 }
1156
1157                 /* Ensure we don't reprocess this message. */
1158                 remove_deferred_open_smb_message(mid);
1159         }
1160
1161         if (!check_name(fname,conn)) {
1162                 return map_nt_error_from_unix(errno);
1163         } 
1164
1165         new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1166         if (file_existed) {
1167                 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1168         }
1169
1170         /* ignore any oplock requests if oplocks are disabled */
1171         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1172             IS_VETO_OPLOCK_PATH(conn, fname)) {
1173                 /* Mask off everything except the private Samba bits. */
1174                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1175         }
1176
1177         /* this is for OS/2 long file names - say we don't support them */
1178         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1179                 /* OS/2 Workplace shell fix may be main code stream in a later
1180                  * release. */ 
1181                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1182                          "supported.\n"));
1183                 if (use_nt_status()) {
1184                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1185                 }
1186                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1187         }
1188
1189         switch( create_disposition ) {
1190                 /*
1191                  * Currently we're using FILE_SUPERSEDE as the same as
1192                  * FILE_OVERWRITE_IF but they really are
1193                  * different. FILE_SUPERSEDE deletes an existing file
1194                  * (requiring delete access) then recreates it.
1195                  */
1196                 case FILE_SUPERSEDE:
1197                         /* If file exists replace/overwrite. If file doesn't
1198                          * exist create. */
1199                         flags2 |= (O_CREAT | O_TRUNC);
1200                         break;
1201
1202                 case FILE_OVERWRITE_IF:
1203                         /* If file exists replace/overwrite. If file doesn't
1204                          * exist create. */
1205                         flags2 |= (O_CREAT | O_TRUNC);
1206                         break;
1207
1208                 case FILE_OPEN:
1209                         /* If file exists open. If file doesn't exist error. */
1210                         if (!file_existed) {
1211                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1212                                          "requested for file %s and file "
1213                                          "doesn't exist.\n", fname ));
1214                                 errno = ENOENT;
1215                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1216                         }
1217                         break;
1218
1219                 case FILE_OVERWRITE:
1220                         /* If file exists overwrite. If file doesn't exist
1221                          * error. */
1222                         if (!file_existed) {
1223                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1224                                          "requested for file %s and file "
1225                                          "doesn't exist.\n", fname ));
1226                                 errno = ENOENT;
1227                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1228                         }
1229                         flags2 |= O_TRUNC;
1230                         break;
1231
1232                 case FILE_CREATE:
1233                         /* If file exists error. If file doesn't exist
1234                          * create. */
1235                         if (file_existed) {
1236                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1237                                          "requested for file %s and file "
1238                                          "already exists.\n", fname ));
1239                                 if (S_ISDIR(psbuf->st_mode)) {
1240                                         errno = EISDIR;
1241                                 } else {
1242                                         errno = EEXIST;
1243                                 }
1244                                 return map_nt_error_from_unix(errno);
1245                         }
1246                         flags2 |= (O_CREAT|O_EXCL);
1247                         break;
1248
1249                 case FILE_OPEN_IF:
1250                         /* If file exists open. If file doesn't exist
1251                          * create. */
1252                         flags2 |= O_CREAT;
1253                         break;
1254
1255                 default:
1256                         return NT_STATUS_INVALID_PARAMETER;
1257         }
1258
1259         /* We only care about matching attributes on file exists and
1260          * overwrite. */
1261
1262         if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1263                              (create_disposition == FILE_OVERWRITE_IF))) {
1264                 if (!open_match_attributes(conn, fname,
1265                                            existing_dos_attributes,
1266                                            new_dos_attributes, psbuf->st_mode,
1267                                            unx_mode, &new_unx_mode)) {
1268                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1269                                  "for file %s (%x %x) (0%o, 0%o)\n",
1270                                  fname, existing_dos_attributes,
1271                                  new_dos_attributes,
1272                                  (unsigned int)psbuf->st_mode,
1273                                  (unsigned int)unx_mode ));
1274                         errno = EACCES;
1275                         return NT_STATUS_ACCESS_DENIED;
1276                 }
1277         }
1278
1279         /* This is a nasty hack - must fix... JRA. */
1280         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1281                 open_access_mask = access_mask = FILE_GENERIC_ALL;
1282         }
1283
1284         /*
1285          * Convert GENERIC bits to specific bits.
1286          */
1287
1288         se_map_generic(&access_mask, &file_generic_mapping);
1289         open_access_mask = access_mask;
1290
1291         if (flags2 & O_TRUNC) {
1292                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1293         }
1294
1295         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1296                    "access_mask=0x%x\n", fname, access_mask ));
1297
1298         /*
1299          * Note that we ignore the append flag as append does not
1300          * mean the same thing under DOS and Unix.
1301          */
1302
1303         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1304                 /* DENY_DOS opens are always underlying read-write on the
1305                    file handle, no matter what the requested access mask
1306                     says. */
1307                 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1308                         access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1309                         flags = O_RDWR;
1310                 } else {
1311                         flags = O_WRONLY;
1312                 }
1313         } else {
1314                 flags = O_RDONLY;
1315         }
1316
1317         /*
1318          * Currently we only look at FILE_WRITE_THROUGH for create options.
1319          */
1320
1321 #if defined(O_SYNC)
1322         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1323                 flags2 |= O_SYNC;
1324         }
1325 #endif /* O_SYNC */
1326   
1327         if (!CAN_WRITE(conn)) {
1328                 /*
1329                  * We should really return a permission denied error if either
1330                  * O_CREAT or O_TRUNC are set, but for compatibility with
1331                  * older versions of Samba we just AND them out.
1332                  */
1333                 flags2 &= ~(O_CREAT|O_TRUNC);
1334         }
1335
1336         /*
1337          * Ensure we can't write on a read-only share or file.
1338          */
1339
1340         if (flags != O_RDONLY && file_existed &&
1341             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1342                 DEBUG(5,("open_file_ntcreate: write access requested for "
1343                          "file %s on read only %s\n",
1344                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1345                 errno = EACCES;
1346                 return NT_STATUS_ACCESS_DENIED;
1347         }
1348
1349         status = file_new(conn, &fsp);
1350         if(!NT_STATUS_IS_OK(status)) {
1351                 return status;
1352         }
1353
1354         fsp->dev = psbuf->st_dev;
1355         fsp->inode = psbuf->st_ino;
1356         fsp->share_access = share_access;
1357         fsp->fh->private_options = create_options;
1358         fsp->access_mask = open_access_mask; /* We change this to the
1359                                               * requested access_mask after
1360                                               * the open is done. */
1361         /* Ensure no SAMBA_PRIVATE bits can be set. */
1362         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1363
1364         if (timeval_is_zero(&request_time)) {
1365                 request_time = fsp->open_time;
1366         }
1367
1368         if (file_existed) {
1369                 dev = psbuf->st_dev;
1370                 inode = psbuf->st_ino;
1371
1372                 lck = get_share_mode_lock(NULL, dev, inode,
1373                                           conn->connectpath,
1374                                           fname);
1375
1376                 if (lck == NULL) {
1377                         file_free(fsp);
1378                         DEBUG(0, ("Could not get share mode lock\n"));
1379                         return NT_STATUS_SHARING_VIOLATION;
1380                 }
1381
1382                 /* First pass - send break only on batch oplocks. */
1383                 if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1384                         schedule_defer_open(lck, request_time);
1385                         TALLOC_FREE(lck);
1386                         file_free(fsp);
1387                         return NT_STATUS_SHARING_VIOLATION;
1388                 }
1389
1390                 /* Use the client requested access mask here, not the one we
1391                  * open with. */
1392                 status = open_mode_check(conn, fname, lck,
1393                                          access_mask, share_access,
1394                                          create_options, &file_existed);
1395
1396                 if (NT_STATUS_IS_OK(status)) {
1397                         /* We might be going to allow this open. Check oplock
1398                          * status again. */
1399                         /* Second pass - send break for both batch or
1400                          * exclusive oplocks. */
1401                         if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1402                                 schedule_defer_open(lck, request_time);
1403                                 TALLOC_FREE(lck);
1404                                 file_free(fsp);
1405                                 return NT_STATUS_SHARING_VIOLATION;
1406                         }
1407                 }
1408
1409                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1410                         /* DELETE_PENDING is not deferred for a second */
1411                         TALLOC_FREE(lck);
1412                         file_free(fsp);
1413                         return status;
1414                 }
1415
1416                 if (!NT_STATUS_IS_OK(status)) {
1417                         uint32 can_access_mask;
1418                         BOOL can_access = True;
1419
1420                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1421
1422                         /* Check if this can be done with the deny_dos and fcb
1423                          * calls. */
1424                         if (create_options &
1425                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1426                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1427                                 files_struct *fsp_dup;
1428
1429                                 /* Use the client requested access mask here,
1430                                  * not the one we open with. */
1431                                 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1432                                                           inode, access_mask,
1433                                                           share_access,
1434                                                           create_options);
1435
1436                                 if (fsp_dup) {
1437                                         TALLOC_FREE(lck);
1438                                         file_free(fsp);
1439                                         if (pinfo) {
1440                                                 *pinfo = FILE_WAS_OPENED;
1441                                         }
1442                                         conn->num_files_open++;
1443                                         *result = fsp_dup;
1444                                         return NT_STATUS_OK;
1445                                 }
1446                         }
1447
1448                         /*
1449                          * This next line is a subtlety we need for
1450                          * MS-Access. If a file open will fail due to share
1451                          * permissions and also for security (access) reasons,
1452                          * we need to return the access failed error, not the
1453                          * share error. We can't open the file due to kernel
1454                          * oplock deadlock (it's possible we failed above on
1455                          * the open_mode_check()) so use a userspace check.
1456                          */
1457
1458                         if (flags & O_RDWR) {
1459                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1460                         } else if (flags & O_WRONLY) {
1461                                 can_access_mask = FILE_WRITE_DATA;
1462                         } else {
1463                                 can_access_mask = FILE_READ_DATA;
1464                         }
1465
1466                         if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1467                             !can_access_file(conn,fname,psbuf,can_access_mask)) {
1468                                 can_access = False;
1469                         }
1470
1471                         /* 
1472                          * If we're returning a share violation, ensure we
1473                          * cope with the braindead 1 second delay.
1474                          */
1475
1476                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1477                             lp_defer_sharing_violations()) {
1478                                 struct timeval timeout;
1479                                 struct deferred_open_record state;
1480                                 int timeout_usecs;
1481
1482                                 /* this is a hack to speed up torture tests
1483                                    in 'make test' */
1484                                 timeout_usecs = lp_parm_int(SNUM(conn),
1485                                                             "smbd","sharedelay",
1486                                                             SHARING_VIOLATION_USEC_WAIT);
1487
1488                                 /* This is a relative time, added to the absolute
1489                                    request_time value to get the absolute timeout time.
1490                                    Note that if this is the second or greater time we enter
1491                                    this codepath for this particular request mid then
1492                                    request_time is left as the absolute time of the *first*
1493                                    time this request mid was processed. This is what allows
1494                                    the request to eventually time out. */
1495
1496                                 timeout = timeval_set(0, timeout_usecs);
1497
1498                                 /* Nothing actually uses state.delayed_for_oplocks
1499                                    but it's handy to differentiate in debug messages
1500                                    between a 30 second delay due to oplock break, and
1501                                    a 1 second delay for share mode conflicts. */
1502
1503                                 state.delayed_for_oplocks = False;
1504                                 state.dev = dev;
1505                                 state.inode = inode;
1506
1507                                 if (!request_timed_out(request_time,
1508                                                        timeout)) {
1509                                         defer_open(lck, request_time, timeout,
1510                                                    &state);
1511                                 }
1512                         }
1513
1514                         TALLOC_FREE(lck);
1515                         if (can_access) {
1516                                 /*
1517                                  * We have detected a sharing violation here
1518                                  * so return the correct error code
1519                                  */
1520                                 status = NT_STATUS_SHARING_VIOLATION;
1521                         } else {
1522                                 status = NT_STATUS_ACCESS_DENIED;
1523                         }
1524                         file_free(fsp);
1525                         return status;
1526                 }
1527
1528                 /*
1529                  * We exit this block with the share entry *locked*.....
1530                  */
1531         }
1532
1533         SMB_ASSERT(!file_existed || (lck != NULL));
1534
1535         /*
1536          * Ensure we pay attention to default ACLs on directories if required.
1537          */
1538
1539         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1540             (def_acl = directory_has_default_acl(conn,
1541                                                  parent_dirname(fname)))) {
1542                 unx_mode = 0777;
1543         }
1544
1545         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1546                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1547                  (unsigned int)flags, (unsigned int)flags2,
1548                  (unsigned int)unx_mode, (unsigned int)access_mask,
1549                  (unsigned int)open_access_mask));
1550
1551         /*
1552          * open_file strips any O_TRUNC flags itself.
1553          */
1554
1555         fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1556                              access_mask, open_access_mask);
1557
1558         if (!NT_STATUS_IS_OK(fsp_open)) {
1559                 if (lck != NULL) {
1560                         TALLOC_FREE(lck);
1561                 }
1562                 file_free(fsp);
1563                 return fsp_open;
1564         }
1565
1566         if (!file_existed) {
1567
1568                 /*
1569                  * Deal with the race condition where two smbd's detect the
1570                  * file doesn't exist and do the create at the same time. One
1571                  * of them will win and set a share mode, the other (ie. this
1572                  * one) should check if the requested share mode for this
1573                  * create is allowed.
1574                  */
1575
1576                 /*
1577                  * Now the file exists and fsp is successfully opened,
1578                  * fsp->dev and fsp->inode are valid and should replace the
1579                  * dev=0,inode=0 from a non existent file. Spotted by
1580                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1581                  */
1582
1583                 dev = fsp->dev;
1584                 inode = fsp->inode;
1585
1586                 lck = get_share_mode_lock(NULL, dev, inode,
1587                                           conn->connectpath,
1588                                           fname);
1589
1590                 if (lck == NULL) {
1591                         DEBUG(0, ("open_file_ntcreate: Could not get share "
1592                                   "mode lock for %s\n", fname));
1593                         fd_close(conn, fsp);
1594                         file_free(fsp);
1595                         return NT_STATUS_SHARING_VIOLATION;
1596                 }
1597
1598                 status = open_mode_check(conn, fname, lck,
1599                                          access_mask, share_access,
1600                                          create_options, &file_existed);
1601
1602                 if (!NT_STATUS_IS_OK(status)) {
1603                         struct deferred_open_record state;
1604
1605                         fd_close(conn, fsp);
1606                         file_free(fsp);
1607
1608                         state.delayed_for_oplocks = False;
1609                         state.dev = dev;
1610                         state.inode = inode;
1611
1612                         /* Do it all over again immediately. In the second
1613                          * round we will find that the file existed and handle
1614                          * the DELETE_PENDING and FCB cases correctly. No need
1615                          * to duplicate the code here. Essentially this is a
1616                          * "goto top of this function", but don't tell
1617                          * anybody... */
1618
1619                         defer_open(lck, request_time, timeval_zero(),
1620                                    &state);
1621                         TALLOC_FREE(lck);
1622                         return status;
1623                 }
1624
1625                 /*
1626                  * We exit this block with the share entry *locked*.....
1627                  */
1628
1629         }
1630
1631         SMB_ASSERT(lck != NULL);
1632
1633         /* note that we ignore failure for the following. It is
1634            basically a hack for NFS, and NFS will never set one of
1635            these only read them. Nobody but Samba can ever set a deny
1636            mode and we have already checked our more authoritative
1637            locking database for permission to set this deny mode. If
1638            the kernel refuses the operations then the kernel is wrong.
1639            note that GPFS supports it as well - jmcd */
1640
1641         ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1642         if(ret_flock == -1 ){
1643
1644                 talloc_free(lck);
1645                 fd_close(conn, fsp);
1646                 file_free(fsp);
1647                 
1648                 return NT_STATUS_SHARING_VIOLATION;
1649         }
1650
1651         /*
1652          * At this point onwards, we can guarentee that the share entry
1653          * is locked, whether we created the file or not, and that the
1654          * deny mode is compatible with all current opens.
1655          */
1656
1657         /*
1658          * If requested, truncate the file.
1659          */
1660
1661         if (flags2&O_TRUNC) {
1662                 /*
1663                  * We are modifing the file after open - update the stat
1664                  * struct..
1665                  */
1666                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1667                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1668                         status = map_nt_error_from_unix(errno);
1669                         TALLOC_FREE(lck);
1670                         fd_close(conn,fsp);
1671                         file_free(fsp);
1672                         return status;
1673                 }
1674         }
1675
1676         /* Record the options we were opened with. */
1677         fsp->share_access = share_access;
1678         fsp->fh->private_options = create_options;
1679         fsp->access_mask = access_mask;
1680
1681         if (file_existed) {
1682                 /* stat opens on existing files don't get oplocks. */
1683                 if (is_stat_open(open_access_mask)) {
1684                         fsp->oplock_type = NO_OPLOCK;
1685                 }
1686
1687                 if (!(flags2 & O_TRUNC)) {
1688                         info = FILE_WAS_OPENED;
1689                 } else {
1690                         info = FILE_WAS_OVERWRITTEN;
1691                 }
1692         } else {
1693                 info = FILE_WAS_CREATED;
1694                 /* Change the owner if required. */
1695                 if (lp_inherit_owner(SNUM(conn))) {
1696                         change_owner_to_parent(conn, fsp, fsp->fsp_name,
1697                                                psbuf);
1698                 }
1699         }
1700
1701         if (pinfo) {
1702                 *pinfo = info;
1703         }
1704
1705         /* 
1706          * Setup the oplock info in both the shared memory and
1707          * file structs.
1708          */
1709
1710         if ((fsp->oplock_type != NO_OPLOCK) &&
1711             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1712                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1713                         /* Could not get the kernel oplock */
1714                         fsp->oplock_type = NO_OPLOCK;
1715                 }
1716         }
1717         set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type);
1718
1719         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1720             info == FILE_WAS_SUPERSEDED) {
1721
1722                 /* Handle strange delete on close create semantics. */
1723                 if (create_options & FILE_DELETE_ON_CLOSE) {
1724                         status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1725
1726                         if (!NT_STATUS_IS_OK(status)) {
1727                                 /* Remember to delete the mode we just added. */
1728                                 del_share_mode(lck, fsp);
1729                                 TALLOC_FREE(lck);
1730                                 fd_close(conn,fsp);
1731                                 file_free(fsp);
1732                                 return status;
1733                         }
1734                         /* Note that here we set the *inital* delete on close flag,
1735                            not the regular one. */
1736                         set_delete_on_close_token(lck, &current_user.ut);
1737                         lck->initial_delete_on_close = True;
1738                         lck->modified = True;
1739                 }
1740         
1741                 /* Files should be initially set as archive */
1742                 if (lp_map_archive(SNUM(conn)) ||
1743                     lp_store_dos_attributes(SNUM(conn))) {
1744                         file_set_dosmode(conn, fname,
1745                                          new_dos_attributes | aARCH, NULL,
1746                                          True);
1747                 }
1748         }
1749
1750         /*
1751          * Take care of inherited ACLs on created files - if default ACL not
1752          * selected.
1753          */
1754
1755         if (!file_existed && !def_acl) {
1756
1757                 int saved_errno = errno; /* We might get ENOSYS in the next
1758                                           * call.. */
1759
1760                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1761                     errno == ENOSYS) {
1762                         errno = saved_errno; /* Ignore ENOSYS */
1763                 }
1764
1765         } else if (new_unx_mode) {
1766
1767                 int ret = -1;
1768
1769                 /* Attributes need changing. File already existed. */
1770
1771                 {
1772                         int saved_errno = errno; /* We might get ENOSYS in the
1773                                                   * next call.. */
1774                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1775                                                  new_unx_mode);
1776
1777                         if (ret == -1 && errno == ENOSYS) {
1778                                 errno = saved_errno; /* Ignore ENOSYS */
1779                         } else {
1780                                 DEBUG(5, ("open_file_ntcreate: reset "
1781                                           "attributes of file %s to 0%o\n",
1782                                           fname, (unsigned int)new_unx_mode));
1783                                 ret = 0; /* Don't do the fchmod below. */
1784                         }
1785                 }
1786
1787                 if ((ret == -1) &&
1788                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1789                         DEBUG(5, ("open_file_ntcreate: failed to reset "
1790                                   "attributes of file %s to 0%o\n",
1791                                   fname, (unsigned int)new_unx_mode));
1792         }
1793
1794         /* If this is a successful open, we must remove any deferred open
1795          * records. */
1796         del_deferred_open_entry(lck, mid);
1797         TALLOC_FREE(lck);
1798
1799         conn->num_files_open++;
1800
1801         *result = fsp;
1802         return NT_STATUS_OK;
1803 }
1804
1805 /****************************************************************************
1806  Open a file for for write to ensure that we can fchmod it.
1807 ****************************************************************************/
1808
1809 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1810                           SMB_STRUCT_STAT *psbuf, files_struct **result)
1811 {
1812         files_struct *fsp = NULL;
1813         NTSTATUS status;
1814
1815         if (!VALID_STAT(*psbuf)) {
1816                 return NT_STATUS_INVALID_PARAMETER;
1817         }
1818
1819         status = file_new(conn, &fsp);
1820         if(!NT_STATUS_IS_OK(status)) {
1821                 return status;
1822         }
1823
1824         /* note! we must use a non-zero desired access or we don't get
1825            a real file descriptor. Oh what a twisted web we weave. */
1826         status = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA,FILE_WRITE_DATA);
1827
1828         /* 
1829          * This is not a user visible file open.
1830          * Don't set a share mode and don't increment
1831          * the conn->num_files_open.
1832          */
1833
1834         if (!NT_STATUS_IS_OK(status)) {
1835                 file_free(fsp);
1836                 return status;
1837         }
1838
1839         *result = fsp;
1840         return NT_STATUS_OK;
1841 }
1842
1843 /****************************************************************************
1844  Close the fchmod file fd - ensure no locks are lost.
1845 ****************************************************************************/
1846
1847 int close_file_fchmod(files_struct *fsp)
1848 {
1849         int ret = fd_close(fsp->conn, fsp);
1850         file_free(fsp);
1851         return ret;
1852 }
1853
1854 /****************************************************************************
1855  Open a directory from an NT SMB call.
1856 ****************************************************************************/
1857
1858 NTSTATUS open_directory(connection_struct *conn,
1859                         const char *fname,
1860                         SMB_STRUCT_STAT *psbuf,
1861                         uint32 access_mask,
1862                         uint32 share_access,
1863                         uint32 create_disposition,
1864                         uint32 create_options,
1865                         int *pinfo,
1866                         files_struct **result)
1867 {
1868         files_struct *fsp = NULL;
1869         BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1870         BOOL create_dir = False;
1871         struct share_mode_lock *lck = NULL;
1872         NTSTATUS status;
1873         int info = 0;
1874
1875         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1876                  "share_access = 0x%x create_options = 0x%x, "
1877                  "create_disposition = 0x%x\n",
1878                  fname,
1879                  (unsigned int)access_mask,
1880                  (unsigned int)share_access,
1881                  (unsigned int)create_options,
1882                  (unsigned int)create_disposition));
1883
1884         if (is_ntfs_stream_name(fname)) {
1885                 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1886                 return NT_STATUS_NOT_A_DIRECTORY;
1887         }
1888
1889         switch( create_disposition ) {
1890                 case FILE_OPEN:
1891                         /* If directory exists open. If directory doesn't
1892                          * exist error. */
1893                         if (!dir_existed) {
1894                                 DEBUG(5,("open_directory: FILE_OPEN requested "
1895                                          "for directory %s and it doesn't "
1896                                          "exist.\n", fname ));
1897                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1898                         }
1899                         info = FILE_WAS_OPENED;
1900                         break;
1901
1902                 case FILE_CREATE:
1903                         /* If directory exists error. If directory doesn't
1904                          * exist create. */
1905                         if (dir_existed) {
1906                                 DEBUG(5,("open_directory: FILE_CREATE "
1907                                          "requested for directory %s and it "
1908                                          "already exists.\n", fname ));
1909                                 if (use_nt_status()) {
1910                                         return NT_STATUS_OBJECT_NAME_COLLISION;
1911                                 } else {
1912                                         return NT_STATUS_DOS(ERRDOS,
1913                                                              ERRfilexists);
1914                                 }
1915                         }
1916                         create_dir = True;
1917                         info = FILE_WAS_CREATED;
1918                         break;
1919
1920                 case FILE_OPEN_IF:
1921                         /* If directory exists open. If directory doesn't
1922                          * exist create. */
1923                         if (!dir_existed) {
1924                                 create_dir = True;
1925                                 info = FILE_WAS_CREATED;
1926                         } else {
1927                                 info = FILE_WAS_OPENED;
1928                         }
1929                         break;
1930
1931                 case FILE_SUPERSEDE:
1932                 case FILE_OVERWRITE:
1933                 case FILE_OVERWRITE_IF:
1934                 default:
1935                         DEBUG(5,("open_directory: invalid create_disposition "
1936                                  "0x%x for directory %s\n",
1937                                  (unsigned int)create_disposition, fname));
1938                         return NT_STATUS_INVALID_PARAMETER;
1939         }
1940
1941         if (create_dir) {
1942                 /*
1943                  * Try and create the directory.
1944                  */
1945
1946                 /* We know bad_path is false as it's caught earlier. */
1947
1948                 status = mkdir_internal(conn, fname, False);
1949
1950                 if (!NT_STATUS_IS_OK(status)) {
1951                         DEBUG(2,("open_directory: unable to create %s. "
1952                                  "Error was %s\n", fname, strerror(errno) ));
1953                         /* Ensure we return the correct NT status to the
1954                          * client. */
1955                         return status;
1956                 }
1957
1958                 /* Ensure we're checking for a symlink here.... */
1959                 /* We don't want to get caught by a symlink racer. */
1960
1961                 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1962                         return map_nt_error_from_unix(errno);
1963                 }
1964
1965                 if(!S_ISDIR(psbuf->st_mode)) {
1966                         DEBUG(0,("open_directory: %s is not a directory !\n",
1967                                  fname ));
1968                         return NT_STATUS_NOT_A_DIRECTORY;
1969                 }
1970         }
1971
1972         status = file_new(conn, &fsp);
1973         if(!NT_STATUS_IS_OK(status)) {
1974                 return status;
1975         }
1976
1977         /*
1978          * Setup the files_struct for it.
1979          */
1980         
1981         fsp->mode = psbuf->st_mode;
1982         fsp->inode = psbuf->st_ino;
1983         fsp->dev = psbuf->st_dev;
1984         fsp->vuid = current_user.vuid;
1985         fsp->file_pid = global_smbpid;
1986         fsp->can_lock = False;
1987         fsp->can_read = False;
1988         fsp->can_write = False;
1989
1990         fsp->share_access = share_access;
1991         fsp->fh->private_options = create_options;
1992         fsp->access_mask = access_mask;
1993
1994         fsp->print_file = False;
1995         fsp->modified = False;
1996         fsp->oplock_type = NO_OPLOCK;
1997         fsp->sent_oplock_break = NO_BREAK_SENT;
1998         fsp->is_directory = True;
1999         fsp->is_stat = False;
2000         string_set(&fsp->fsp_name,fname);
2001
2002         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
2003                                   conn->connectpath,
2004                                   fname);
2005
2006         if (lck == NULL) {
2007                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2008                 file_free(fsp);
2009                 return NT_STATUS_SHARING_VIOLATION;
2010         }
2011
2012         status = open_mode_check(conn, fname, lck,
2013                                 access_mask, share_access,
2014                                 create_options, &dir_existed);
2015
2016         if (!NT_STATUS_IS_OK(status)) {
2017                 TALLOC_FREE(lck);
2018                 file_free(fsp);
2019                 return status;
2020         }
2021
2022         set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK);
2023
2024         /* For directories the delete on close bit at open time seems
2025            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2026         if (create_options & FILE_DELETE_ON_CLOSE) {
2027                 status = can_set_delete_on_close(fsp, True, 0);
2028                 if (!NT_STATUS_IS_OK(status)) {
2029                         TALLOC_FREE(lck);
2030                         file_free(fsp);
2031                         return status;
2032                 }
2033
2034                 set_delete_on_close_token(lck, &current_user.ut);
2035                 lck->initial_delete_on_close = True;
2036                 lck->modified = True;
2037         }
2038
2039         TALLOC_FREE(lck);
2040
2041         /* Change the owner if required. */
2042         if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2043                 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2044         }
2045
2046         if (pinfo) {
2047                 *pinfo = info;
2048         }
2049
2050         conn->num_files_open++;
2051
2052         *result = fsp;
2053         return NT_STATUS_OK;
2054 }
2055
2056 /****************************************************************************
2057  Open a pseudo-file (no locking checks - a 'stat' open).
2058 ****************************************************************************/
2059
2060 NTSTATUS open_file_stat(connection_struct *conn, const char *fname,
2061                         SMB_STRUCT_STAT *psbuf, files_struct **result)
2062 {
2063         files_struct *fsp = NULL;
2064         NTSTATUS status;
2065
2066         if (!VALID_STAT(*psbuf)) {
2067                 return NT_STATUS_INVALID_PARAMETER;
2068         }
2069
2070         /* Can't 'stat' open directories. */
2071         if(S_ISDIR(psbuf->st_mode)) {
2072                 return NT_STATUS_FILE_IS_A_DIRECTORY;
2073         }
2074
2075         status = file_new(conn, &fsp);
2076         if(!NT_STATUS_IS_OK(status)) {
2077                 return status;
2078         }
2079
2080         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2081
2082         /*
2083          * Setup the files_struct for it.
2084          */
2085         
2086         fsp->mode = psbuf->st_mode;
2087         fsp->inode = psbuf->st_ino;
2088         fsp->dev = psbuf->st_dev;
2089         fsp->vuid = current_user.vuid;
2090         fsp->file_pid = global_smbpid;
2091         fsp->can_lock = False;
2092         fsp->can_read = False;
2093         fsp->can_write = False;
2094         fsp->print_file = False;
2095         fsp->modified = False;
2096         fsp->oplock_type = NO_OPLOCK;
2097         fsp->sent_oplock_break = NO_BREAK_SENT;
2098         fsp->is_directory = False;
2099         fsp->is_stat = True;
2100         string_set(&fsp->fsp_name,fname);
2101
2102         conn->num_files_open++;
2103
2104         *result = fsp;
2105         return NT_STATUS_OK;
2106 }
2107
2108 /****************************************************************************
2109  Receive notification that one of our open files has been renamed by another
2110  smbd process.
2111 ****************************************************************************/
2112
2113 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2114 {
2115         files_struct *fsp;
2116         char *frm = (char *)buf;
2117         SMB_DEV_T dev;
2118         SMB_INO_T inode;
2119         const char *sharepath;
2120         const char *newname;
2121         size_t sp_len;
2122
2123         if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2124                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2125                 return;
2126         }
2127
2128         /* Unpack the message. */
2129         dev = DEV_T_VAL(frm,0);
2130         inode = INO_T_VAL(frm,8);
2131         sharepath = &frm[16];
2132         newname = sharepath + strlen(sharepath) + 1;
2133         sp_len = strlen(sharepath);
2134
2135         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2136                 "dev %x, inode  %.0f\n",
2137                 sharepath, newname, (unsigned int)dev, (double)inode ));
2138
2139         for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2140                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2141                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2142                                 fsp->fnum, fsp->fsp_name, newname ));
2143                         string_set(&fsp->fsp_name, newname);
2144                 } else {
2145                         /* TODO. JRA. */
2146                         /* Now we have the complete path we can work out if this is
2147                            actually within this share and adjust newname accordingly. */
2148                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2149                                 "not sharepath %s) "
2150                                 "fnum %d from %s -> %s\n",
2151                                 fsp->conn->connectpath,
2152                                 sharepath,
2153                                 fsp->fnum,
2154                                 fsp->fsp_name,
2155                                 newname ));
2156                 }
2157         }
2158 }