743f040911184d93a9b3ee17f7c81017294dd649
[ira/wip.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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23
24 extern const struct generic_mapping file_generic_mapping;
25 extern struct current_user current_user;
26 extern userdom_struct current_user_info;
27 extern bool global_client_failed_oplock_break;
28
29 struct deferred_open_record {
30         bool delayed_for_oplocks;
31         struct file_id id;
32 };
33
34 /****************************************************************************
35  fd support routines - attempt to do a dos_open.
36 ****************************************************************************/
37
38 static NTSTATUS fd_open(struct connection_struct *conn,
39                     const char *fname, 
40                     files_struct *fsp,
41                     int flags,
42                     mode_t mode)
43 {
44         NTSTATUS status = NT_STATUS_OK;
45
46 #ifdef O_NOFOLLOW
47         /* 
48          * Never follow symlinks on a POSIX client. The
49          * client should be doing this.
50          */
51
52         if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
53                 flags |= O_NOFOLLOW;
54         }
55 #endif
56
57         fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
58         if (fsp->fh->fd == -1) {
59                 status = map_nt_error_from_unix(errno);
60         }
61
62         DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
63                     fname, flags, (int)mode, fsp->fh->fd,
64                 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
65
66         return status;
67 }
68
69 /****************************************************************************
70  Close the file associated with a fsp.
71 ****************************************************************************/
72
73 NTSTATUS fd_close(struct connection_struct *conn, files_struct *fsp)
74 {
75         if (fsp->fh->fd == -1) {
76                 return NT_STATUS_OK; /* What we used to call a stat open. */
77         }
78         if (fsp->fh->ref_count > 1) {
79                 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
80         }
81         return fd_close_posix(fsp);
82 }
83
84 /****************************************************************************
85  Change the ownership of a file to that of the parent directory.
86  Do this by fd if possible.
87 ****************************************************************************/
88
89 static void change_file_owner_to_parent(connection_struct *conn,
90                                         const char *inherit_from_dir,
91                                         files_struct *fsp)
92 {
93         SMB_STRUCT_STAT parent_st;
94         int ret;
95
96         ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
97         if (ret == -1) {
98                 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
99                          "directory %s. Error was %s\n",
100                          inherit_from_dir, strerror(errno) ));
101                 return;
102         }
103
104         become_root();
105         ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
106         unbecome_root();
107         if (ret == -1) {
108                 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
109                          "file %s to parent directory uid %u. Error "
110                          "was %s\n", fsp->fsp_name,
111                          (unsigned int)parent_st.st_uid,
112                          strerror(errno) ));
113         }
114
115         DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
116                   "parent directory uid %u.\n", fsp->fsp_name,
117                   (unsigned int)parent_st.st_uid ));
118 }
119
120 static NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
121                                        const char *inherit_from_dir,
122                                        const char *fname,
123                                        SMB_STRUCT_STAT *psbuf)
124 {
125         char *saved_dir = NULL;
126         SMB_STRUCT_STAT sbuf;
127         SMB_STRUCT_STAT parent_st;
128         TALLOC_CTX *ctx = talloc_stackframe();
129         NTSTATUS status = NT_STATUS_OK;
130         int ret;
131
132         ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
133         if (ret == -1) {
134                 status = map_nt_error_from_unix(errno);
135                 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
136                          "directory %s. Error was %s\n",
137                          inherit_from_dir, strerror(errno) ));
138                 TALLOC_FREE(ctx);
139                 return status;
140         }
141
142         /* We've already done an lstat into psbuf, and we know it's a
143            directory. If we can cd into the directory and the dev/ino
144            are the same then we can safely chown without races as
145            we're locking the directory in place by being in it.  This
146            should work on any UNIX (thanks tridge :-). JRA.
147         */
148
149         saved_dir = vfs_GetWd(ctx,conn);
150         if (!saved_dir) {
151                 status = map_nt_error_from_unix(errno);
152                 DEBUG(0,("change_dir_owner_to_parent: failed to get "
153                          "current working directory. Error was %s\n",
154                          strerror(errno)));
155                 TALLOC_FREE(ctx);
156                 return status;
157         }
158
159         /* Chdir into the new path. */
160         if (vfs_ChDir(conn, fname) == -1) {
161                 status = map_nt_error_from_unix(errno);
162                 DEBUG(0,("change_dir_owner_to_parent: failed to change "
163                          "current working directory to %s. Error "
164                          "was %s\n", fname, strerror(errno) ));
165                 goto out;
166         }
167
168         if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
169                 status = map_nt_error_from_unix(errno);
170                 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
171                          "directory '.' (%s) Error was %s\n",
172                          fname, strerror(errno)));
173                 goto out;
174         }
175
176         /* Ensure we're pointing at the same place. */
177         if (sbuf.st_dev != psbuf->st_dev ||
178             sbuf.st_ino != psbuf->st_ino ||
179             sbuf.st_mode != psbuf->st_mode ) {
180                 DEBUG(0,("change_dir_owner_to_parent: "
181                          "device/inode/mode on directory %s changed. "
182                          "Refusing to chown !\n", fname ));
183                 status = NT_STATUS_ACCESS_DENIED;
184                 goto out;
185         }
186
187         become_root();
188         ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
189         unbecome_root();
190         if (ret == -1) {
191                 status = map_nt_error_from_unix(errno);
192                 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
193                           "directory %s to parent directory uid %u. "
194                           "Error was %s\n", fname,
195                           (unsigned int)parent_st.st_uid, strerror(errno) ));
196                 goto out;
197         }
198
199         DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
200                   "directory %s to parent directory uid %u.\n",
201                   fname, (unsigned int)parent_st.st_uid ));
202
203  out:
204
205         TALLOC_FREE(ctx);
206         vfs_ChDir(conn,saved_dir);
207         return status;
208 }
209
210 /****************************************************************************
211  Open a file.
212 ****************************************************************************/
213
214 static NTSTATUS open_file(files_struct *fsp,
215                           connection_struct *conn,
216                           struct smb_request *req,
217                           const char *parent_dir,
218                           const char *name,
219                           const char *path,
220                           SMB_STRUCT_STAT *psbuf,
221                           int flags,
222                           mode_t unx_mode,
223                           uint32 access_mask, /* client requested access mask. */
224                           uint32 open_access_mask) /* what we're actually using in the open. */
225 {
226         NTSTATUS status = NT_STATUS_OK;
227         int accmode = (flags & O_ACCMODE);
228         int local_flags = flags;
229         bool file_existed = VALID_STAT(*psbuf);
230
231         fsp->fh->fd = -1;
232         errno = EPERM;
233
234         /* Check permissions */
235
236         /*
237          * This code was changed after seeing a client open request 
238          * containing the open mode of (DENY_WRITE/read-only) with
239          * the 'create if not exist' bit set. The previous code
240          * would fail to open the file read only on a read-only share
241          * as it was checking the flags parameter  directly against O_RDONLY,
242          * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
243          * JRA.
244          */
245
246         if (!CAN_WRITE(conn)) {
247                 /* It's a read-only share - fail if we wanted to write. */
248                 if(accmode != O_RDONLY) {
249                         DEBUG(3,("Permission denied opening %s\n", path));
250                         return NT_STATUS_ACCESS_DENIED;
251                 } else if(flags & O_CREAT) {
252                         /* We don't want to write - but we must make sure that
253                            O_CREAT doesn't create the file if we have write
254                            access into the directory.
255                         */
256                         flags &= ~O_CREAT;
257                         local_flags &= ~O_CREAT;
258                 }
259         }
260
261         /*
262          * This little piece of insanity is inspired by the
263          * fact that an NT client can open a file for O_RDONLY,
264          * but set the create disposition to FILE_EXISTS_TRUNCATE.
265          * If the client *can* write to the file, then it expects to
266          * truncate the file, even though it is opening for readonly.
267          * Quicken uses this stupid trick in backup file creation...
268          * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
269          * for helping track this one down. It didn't bite us in 2.0.x
270          * as we always opened files read-write in that release. JRA.
271          */
272
273         if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
274                 DEBUG(10,("open_file: truncate requested on read-only open "
275                           "for file %s\n", path));
276                 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
277         }
278
279         if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
280             (!file_existed && (local_flags & O_CREAT)) ||
281             ((local_flags & O_TRUNC) == O_TRUNC) ) {
282
283                 /*
284                  * We can't actually truncate here as the file may be locked.
285                  * open_file_ntcreate will take care of the truncate later. JRA.
286                  */
287
288                 local_flags &= ~O_TRUNC;
289
290 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
291                 /*
292                  * We would block on opening a FIFO with no one else on the
293                  * other end. Do what we used to do and add O_NONBLOCK to the
294                  * open flags. JRA.
295                  */
296
297                 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
298                         local_flags |= O_NONBLOCK;
299                 }
300 #endif
301
302                 /* Don't create files with Microsoft wildcard characters. */
303                 if ((local_flags & O_CREAT) && !file_existed &&
304                     ms_has_wild(path))  {
305                         return NT_STATUS_OBJECT_NAME_INVALID;
306                 }
307
308                 /* Actually do the open */
309                 status = fd_open(conn, path, fsp, local_flags, unx_mode);
310                 if (!NT_STATUS_IS_OK(status)) {
311                         DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
312                                  "(flags=%d)\n",
313                                  path,nt_errstr(status),local_flags,flags));
314                         return status;
315                 }
316
317                 if ((local_flags & O_CREAT) && !file_existed) {
318
319                         /* Inherit the ACL if required */
320                         if (lp_inherit_perms(SNUM(conn))) {
321                                 inherit_access_acl(conn, parent_dir, path,
322                                                    unx_mode);
323                         }
324
325                         /* Change the owner if required. */
326                         if (lp_inherit_owner(SNUM(conn))) {
327                                 change_file_owner_to_parent(conn, parent_dir,
328                                                             fsp);
329                         }
330
331                         notify_fname(conn, NOTIFY_ACTION_ADDED,
332                                      FILE_NOTIFY_CHANGE_FILE_NAME, path);
333                 }
334
335         } else {
336                 fsp->fh->fd = -1; /* What we used to call a stat open. */
337         }
338
339         if (!file_existed) {
340                 int ret;
341
342                 if (fsp->fh->fd == -1) {
343                         ret = SMB_VFS_STAT(conn, path, psbuf);
344                 } else {
345                         ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
346                         /* If we have an fd, this stat should succeed. */
347                         if (ret == -1) {
348                                 DEBUG(0,("Error doing fstat on open file %s "
349                                          "(%s)\n", path,strerror(errno) ));
350                         }
351                 }
352
353                 /* For a non-io open, this stat failing means file not found. JRA */
354                 if (ret == -1) {
355                         status = map_nt_error_from_unix(errno);
356                         fd_close(conn, fsp);
357                         return status;
358                 }
359         }
360
361         /*
362          * POSIX allows read-only opens of directories. We don't
363          * want to do this (we use a different code path for this)
364          * so catch a directory open and return an EISDIR. JRA.
365          */
366
367         if(S_ISDIR(psbuf->st_mode)) {
368                 fd_close(conn, fsp);
369                 errno = EISDIR;
370                 return NT_STATUS_FILE_IS_A_DIRECTORY;
371         }
372
373         fsp->mode = psbuf->st_mode;
374         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
375         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
376         fsp->file_pid = req ? req->smbpid : 0;
377         fsp->can_lock = True;
378         fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
379         if (!CAN_WRITE(conn)) {
380                 fsp->can_write = False;
381         } else {
382                 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
383                         True : False;
384         }
385         fsp->print_file = False;
386         fsp->modified = False;
387         fsp->sent_oplock_break = NO_BREAK_SENT;
388         fsp->is_directory = False;
389         fsp->is_stat = False;
390         if (conn->aio_write_behind_list &&
391             is_in_path(path, conn->aio_write_behind_list, conn->case_sensitive)) {
392                 fsp->aio_write_behind = True;
393         }
394
395         string_set(&fsp->fsp_name, path);
396         fsp->wcp = NULL; /* Write cache pointer. */
397
398         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
399                  *current_user_info.smb_name ?
400                  current_user_info.smb_name : conn->user,fsp->fsp_name,
401                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
402                  conn->num_files_open + 1));
403
404         errno = 0;
405         return NT_STATUS_OK;
406 }
407
408 /*******************************************************************
409  Return True if the filename is one of the special executable types.
410 ********************************************************************/
411
412 static bool is_executable(const char *fname)
413 {
414         if ((fname = strrchr_m(fname,'.'))) {
415                 if (strequal(fname,".com") ||
416                     strequal(fname,".dll") ||
417                     strequal(fname,".exe") ||
418                     strequal(fname,".sym")) {
419                         return True;
420                 }
421         }
422         return False;
423 }
424
425 /****************************************************************************
426  Check if we can open a file with a share mode.
427  Returns True if conflict, False if not.
428 ****************************************************************************/
429
430 static bool share_conflict(struct share_mode_entry *entry,
431                            uint32 access_mask,
432                            uint32 share_access)
433 {
434         DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
435                   "entry->share_access = 0x%x, "
436                   "entry->private_options = 0x%x\n",
437                   (unsigned int)entry->access_mask,
438                   (unsigned int)entry->share_access,
439                   (unsigned int)entry->private_options));
440
441         DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
442                   (unsigned int)access_mask, (unsigned int)share_access));
443
444         if ((entry->access_mask & (FILE_WRITE_DATA|
445                                    FILE_APPEND_DATA|
446                                    FILE_READ_DATA|
447                                    FILE_EXECUTE|
448                                    DELETE_ACCESS)) == 0) {
449                 DEBUG(10,("share_conflict: No conflict due to "
450                           "entry->access_mask = 0x%x\n",
451                           (unsigned int)entry->access_mask ));
452                 return False;
453         }
454
455         if ((access_mask & (FILE_WRITE_DATA|
456                             FILE_APPEND_DATA|
457                             FILE_READ_DATA|
458                             FILE_EXECUTE|
459                             DELETE_ACCESS)) == 0) {
460                 DEBUG(10,("share_conflict: No conflict due to "
461                           "access_mask = 0x%x\n",
462                           (unsigned int)access_mask ));
463                 return False;
464         }
465
466 #if 1 /* JRA TEST - Superdebug. */
467 #define CHECK_MASK(num, am, right, sa, share) \
468         DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
469                 (unsigned int)(num), (unsigned int)(am), \
470                 (unsigned int)(right), (unsigned int)(am)&(right) )); \
471         DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
472                 (unsigned int)(num), (unsigned int)(sa), \
473                 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
474         if (((am) & (right)) && !((sa) & (share))) { \
475                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
476 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
477                         (unsigned int)(share) )); \
478                 return True; \
479         }
480 #else
481 #define CHECK_MASK(num, am, right, sa, share) \
482         if (((am) & (right)) && !((sa) & (share))) { \
483                 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
484 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
485                         (unsigned int)(share) )); \
486                 return True; \
487         }
488 #endif
489
490         CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
491                    share_access, FILE_SHARE_WRITE);
492         CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
493                    entry->share_access, FILE_SHARE_WRITE);
494         
495         CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
496                    share_access, FILE_SHARE_READ);
497         CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
498                    entry->share_access, FILE_SHARE_READ);
499
500         CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
501                    share_access, FILE_SHARE_DELETE);
502         CHECK_MASK(6, access_mask, DELETE_ACCESS,
503                    entry->share_access, FILE_SHARE_DELETE);
504
505         DEBUG(10,("share_conflict: No conflict.\n"));
506         return False;
507 }
508
509 #if defined(DEVELOPER)
510 static void validate_my_share_entries(int num,
511                                       struct share_mode_entry *share_entry)
512 {
513         files_struct *fsp;
514
515         if (!procid_is_me(&share_entry->pid)) {
516                 return;
517         }
518
519         if (is_deferred_open_entry(share_entry) &&
520             !open_was_deferred(share_entry->op_mid)) {
521                 char *str = talloc_asprintf(talloc_tos(),
522                         "Got a deferred entry without a request: "
523                         "PANIC: %s\n",
524                         share_mode_str(talloc_tos(), num, share_entry));
525                 smb_panic(str);
526         }
527
528         if (!is_valid_share_mode_entry(share_entry)) {
529                 return;
530         }
531
532         fsp = file_find_dif(share_entry->id,
533                             share_entry->share_file_id);
534         if (!fsp) {
535                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
536                          share_mode_str(talloc_tos(), num, share_entry) ));
537                 smb_panic("validate_my_share_entries: Cannot match a "
538                           "share entry with an open file\n");
539         }
540
541         if (is_deferred_open_entry(share_entry) ||
542             is_unused_share_mode_entry(share_entry)) {
543                 goto panic;
544         }
545
546         if ((share_entry->op_type == NO_OPLOCK) &&
547             (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
548                 /* Someone has already written to it, but I haven't yet
549                  * noticed */
550                 return;
551         }
552
553         if (((uint16)fsp->oplock_type) != share_entry->op_type) {
554                 goto panic;
555         }
556
557         return;
558
559  panic:
560         {
561                 char *str;
562                 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
563                          share_mode_str(talloc_tos(), num, share_entry) ));
564                 str = talloc_asprintf(talloc_tos(),
565                         "validate_my_share_entries: "
566                         "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
567                          fsp->fsp_name, (unsigned int)fsp->oplock_type,
568                          (unsigned int)share_entry->op_type );
569                 smb_panic(str);
570         }
571 }
572 #endif
573
574 static bool is_stat_open(uint32 access_mask)
575 {
576         return (access_mask &&
577                 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
578                                   FILE_WRITE_ATTRIBUTES))==0) &&
579                 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
580                                  FILE_WRITE_ATTRIBUTES)) != 0));
581 }
582
583 /****************************************************************************
584  Deal with share modes
585  Invarient: Share mode must be locked on entry and exit.
586  Returns -1 on error, or number of share modes on success (may be zero).
587 ****************************************************************************/
588
589 static NTSTATUS open_mode_check(connection_struct *conn,
590                                 const char *fname,
591                                 struct share_mode_lock *lck,
592                                 uint32 access_mask,
593                                 uint32 share_access,
594                                 uint32 create_options,
595                                 bool *file_existed)
596 {
597         int i;
598
599         if(lck->num_share_modes == 0) {
600                 return NT_STATUS_OK;
601         }
602
603         *file_existed = True;
604         
605         if (is_stat_open(access_mask)) {
606                 /* Stat open that doesn't trigger oplock breaks or share mode
607                  * checks... ! JRA. */
608                 return NT_STATUS_OK;
609         }
610
611         /* A delete on close prohibits everything */
612
613         if (lck->delete_on_close) {
614                 return NT_STATUS_DELETE_PENDING;
615         }
616
617         /*
618          * Check if the share modes will give us access.
619          */
620         
621 #if defined(DEVELOPER)
622         for(i = 0; i < lck->num_share_modes; i++) {
623                 validate_my_share_entries(i, &lck->share_modes[i]);
624         }
625 #endif
626
627         if (!lp_share_modes(SNUM(conn))) {
628                 return NT_STATUS_OK;
629         }
630
631         /* Now we check the share modes, after any oplock breaks. */
632         for(i = 0; i < lck->num_share_modes; i++) {
633
634                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
635                         continue;
636                 }
637
638                 /* someone else has a share lock on it, check to see if we can
639                  * too */
640                 if (share_conflict(&lck->share_modes[i],
641                                    access_mask, share_access)) {
642                         return NT_STATUS_SHARING_VIOLATION;
643                 }
644         }
645         
646         return NT_STATUS_OK;
647 }
648
649 static bool is_delete_request(files_struct *fsp) {
650         return ((fsp->access_mask == DELETE_ACCESS) &&
651                 (fsp->oplock_type == NO_OPLOCK));
652 }
653
654 /*
655  * 1) No files open at all or internal open: Grant whatever the client wants.
656  *
657  * 2) Exclusive (or batch) oplock around: If the requested access is a delete
658  *    request, break if the oplock around is a batch oplock. If it's another
659  *    requested access type, break.
660  * 
661  * 3) Only level2 around: Grant level2 and do nothing else.
662  */
663
664 static bool delay_for_oplocks(struct share_mode_lock *lck,
665                               files_struct *fsp,
666                               uint16 mid,
667                               int pass_number,
668                               int oplock_request)
669 {
670         int i;
671         struct share_mode_entry *exclusive = NULL;
672         bool valid_entry = False;
673         bool delay_it = False;
674         bool have_level2 = False;
675         NTSTATUS status;
676         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
677
678         if (oplock_request & INTERNAL_OPEN_ONLY) {
679                 fsp->oplock_type = NO_OPLOCK;
680         }
681
682         if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
683                 return False;
684         }
685
686         for (i=0; i<lck->num_share_modes; i++) {
687
688                 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
689                         continue;
690                 }
691
692                 /* At least one entry is not an invalid or deferred entry. */
693                 valid_entry = True;
694
695                 if (pass_number == 1) {
696                         if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
697                                 SMB_ASSERT(exclusive == NULL);                  
698                                 exclusive = &lck->share_modes[i];
699                         }
700                 } else {
701                         if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
702                                 SMB_ASSERT(exclusive == NULL);                  
703                                 exclusive = &lck->share_modes[i];
704                         }
705                 }
706
707                 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
708                         SMB_ASSERT(exclusive == NULL);                  
709                         have_level2 = True;
710                 }
711         }
712
713         if (!valid_entry) {
714                 /* All entries are placeholders or deferred.
715                  * Directly grant whatever the client wants. */
716                 if (fsp->oplock_type == NO_OPLOCK) {
717                         /* Store a level2 oplock, but don't tell the client */
718                         fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
719                 }
720                 return False;
721         }
722
723         if (exclusive != NULL) { /* Found an exclusive oplock */
724                 SMB_ASSERT(!have_level2);
725                 delay_it = is_delete_request(fsp) ?
726                         BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
727         }
728
729         if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
730                 /* We can at most grant level2 as there are other
731                  * level2 or NO_OPLOCK entries. */
732                 fsp->oplock_type = LEVEL_II_OPLOCK;
733         }
734
735         if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
736                 /* Store a level2 oplock, but don't tell the client */
737                 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
738         }
739
740         if (!delay_it) {
741                 return False;
742         }
743
744         /*
745          * Send a break message to the oplock holder and delay the open for
746          * our client.
747          */
748
749         DEBUG(10, ("Sending break request to PID %s\n",
750                    procid_str_static(&exclusive->pid)));
751         exclusive->op_mid = mid;
752
753         /* Create the message. */
754         share_mode_entry_to_message(msg, exclusive);
755
756         /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
757            don't want this set in the share mode struct pointed to by lck. */
758
759         if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
760                 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
761         }
762
763         status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
764                                     MSG_SMB_BREAK_REQUEST,
765                                     (uint8 *)msg,
766                                     MSG_SMB_SHARE_MODE_ENTRY_SIZE);
767         if (!NT_STATUS_IS_OK(status)) {
768                 DEBUG(3, ("Could not send oplock break message: %s\n",
769                           nt_errstr(status)));
770         }
771
772         return True;
773 }
774
775 static bool request_timed_out(struct timeval request_time,
776                               struct timeval timeout)
777 {
778         struct timeval now, end_time;
779         GetTimeOfDay(&now);
780         end_time = timeval_sum(&request_time, &timeout);
781         return (timeval_compare(&end_time, &now) < 0);
782 }
783
784 /****************************************************************************
785  Handle the 1 second delay in returning a SHARING_VIOLATION error.
786 ****************************************************************************/
787
788 static void defer_open(struct share_mode_lock *lck,
789                        struct timeval request_time,
790                        struct timeval timeout,
791                        struct smb_request *req,
792                        struct deferred_open_record *state)
793 {
794         int i;
795
796         /* Paranoia check */
797
798         for (i=0; i<lck->num_share_modes; i++) {
799                 struct share_mode_entry *e = &lck->share_modes[i];
800
801                 if (!is_deferred_open_entry(e)) {
802                         continue;
803                 }
804
805                 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
806                         DEBUG(0, ("Trying to defer an already deferred "
807                                   "request: mid=%d, exiting\n", req->mid));
808                         exit_server("attempt to defer a deferred request");
809                 }
810         }
811
812         /* End paranoia check */
813
814         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
815                   "open entry for mid %u\n",
816                   (unsigned int)request_time.tv_sec,
817                   (unsigned int)request_time.tv_usec,
818                   (unsigned int)req->mid));
819
820         if (!push_deferred_smb_message(req, request_time, timeout,
821                                        (char *)state, sizeof(*state))) {
822                 exit_server("push_deferred_smb_message failed");
823         }
824         add_deferred_open(lck, req->mid, request_time, state->id);
825
826         /*
827          * Push the MID of this packet on the signing queue.
828          * We only do this once, the first time we push the packet
829          * onto the deferred open queue, as this has a side effect
830          * of incrementing the response sequence number.
831          */
832
833         srv_defer_sign_response(req->mid);
834 }
835
836
837 /****************************************************************************
838  On overwrite open ensure that the attributes match.
839 ****************************************************************************/
840
841 static bool open_match_attributes(connection_struct *conn,
842                                   const char *path,
843                                   uint32 old_dos_attr,
844                                   uint32 new_dos_attr,
845                                   mode_t existing_unx_mode,
846                                   mode_t new_unx_mode,
847                                   mode_t *returned_unx_mode)
848 {
849         uint32 noarch_old_dos_attr, noarch_new_dos_attr;
850
851         noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
852         noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
853
854         if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) || 
855            (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
856                 *returned_unx_mode = new_unx_mode;
857         } else {
858                 *returned_unx_mode = (mode_t)0;
859         }
860
861         DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
862                   "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
863                   "returned_unx_mode = 0%o\n",
864                   path,
865                   (unsigned int)old_dos_attr,
866                   (unsigned int)existing_unx_mode,
867                   (unsigned int)new_dos_attr,
868                   (unsigned int)*returned_unx_mode ));
869
870         /* If we're mapping SYSTEM and HIDDEN ensure they match. */
871         if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
872                 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
873                     !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
874                         return False;
875                 }
876         }
877         if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
878                 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
879                     !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
880                         return False;
881                 }
882         }
883         return True;
884 }
885
886 /****************************************************************************
887  Special FCB or DOS processing in the case of a sharing violation.
888  Try and find a duplicated file handle.
889 ****************************************************************************/
890
891 static files_struct *fcb_or_dos_open(connection_struct *conn,
892                                      const char *fname, 
893                                      struct file_id id,
894                                      uint16 file_pid,
895                                      uint16 vuid,
896                                      uint32 access_mask,
897                                      uint32 share_access,
898                                      uint32 create_options)
899 {
900         files_struct *fsp;
901         files_struct *dup_fsp;
902
903         DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
904                  "file %s.\n", fname ));
905
906         for(fsp = file_find_di_first(id); fsp;
907             fsp = file_find_di_next(fsp)) {
908
909                 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
910                           "vuid = %u, file_pid = %u, private_options = 0x%x "
911                           "access_mask = 0x%x\n", fsp->fsp_name,
912                           fsp->fh->fd, (unsigned int)fsp->vuid,
913                           (unsigned int)fsp->file_pid,
914                           (unsigned int)fsp->fh->private_options,
915                           (unsigned int)fsp->access_mask ));
916
917                 if (fsp->fh->fd != -1 &&
918                     fsp->vuid == vuid &&
919                     fsp->file_pid == file_pid &&
920                     (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
921                                                  NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
922                     (fsp->access_mask & FILE_WRITE_DATA) &&
923                     strequal(fsp->fsp_name, fname)) {
924                         DEBUG(10,("fcb_or_dos_open: file match\n"));
925                         break;
926                 }
927         }
928
929         if (!fsp) {
930                 return NULL;
931         }
932
933         /* quite an insane set of semantics ... */
934         if (is_executable(fname) &&
935             (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
936                 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
937                 return NULL;
938         }
939
940         /* We need to duplicate this fsp. */
941         if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
942                                           create_options, &dup_fsp))) {
943                 return NULL;
944         }
945
946         return dup_fsp;
947 }
948
949 /****************************************************************************
950  Open a file with a share mode - old openX method - map into NTCreate.
951 ****************************************************************************/
952
953 bool map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
954                                  uint32 *paccess_mask,
955                                  uint32 *pshare_mode,
956                                  uint32 *pcreate_disposition,
957                                  uint32 *pcreate_options)
958 {
959         uint32 access_mask;
960         uint32 share_mode;
961         uint32 create_disposition;
962         uint32 create_options = 0;
963
964         DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
965                   "open_func = 0x%x\n",
966                   fname, (unsigned int)deny_mode, (unsigned int)open_func ));
967
968         /* Create the NT compatible access_mask. */
969         switch (GET_OPENX_MODE(deny_mode)) {
970                 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
971                 case DOS_OPEN_RDONLY:
972                         access_mask = FILE_GENERIC_READ;
973                         break;
974                 case DOS_OPEN_WRONLY:
975                         access_mask = FILE_GENERIC_WRITE;
976                         break;
977                 case DOS_OPEN_RDWR:
978                 case DOS_OPEN_FCB:
979                         access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
980                         break;
981                 default:
982                         DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
983                                   (unsigned int)GET_OPENX_MODE(deny_mode)));
984                         return False;
985         }
986
987         /* Create the NT compatible create_disposition. */
988         switch (open_func) {
989                 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
990                         create_disposition = FILE_CREATE;
991                         break;
992
993                 case OPENX_FILE_EXISTS_OPEN:
994                         create_disposition = FILE_OPEN;
995                         break;
996
997                 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
998                         create_disposition = FILE_OPEN_IF;
999                         break;
1000        
1001                 case OPENX_FILE_EXISTS_TRUNCATE:
1002                         create_disposition = FILE_OVERWRITE;
1003                         break;
1004
1005                 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
1006                         create_disposition = FILE_OVERWRITE_IF;
1007                         break;
1008
1009                 default:
1010                         /* From samba4 - to be confirmed. */
1011                         if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
1012                                 create_disposition = FILE_CREATE;
1013                                 break;
1014                         }
1015                         DEBUG(10,("map_open_params_to_ntcreate: bad "
1016                                   "open_func 0x%x\n", (unsigned int)open_func));
1017                         return False;
1018         }
1019  
1020         /* Create the NT compatible share modes. */
1021         switch (GET_DENY_MODE(deny_mode)) {
1022                 case DENY_ALL:
1023                         share_mode = FILE_SHARE_NONE;
1024                         break;
1025
1026                 case DENY_WRITE:
1027                         share_mode = FILE_SHARE_READ;
1028                         break;
1029
1030                 case DENY_READ:
1031                         share_mode = FILE_SHARE_WRITE;
1032                         break;
1033
1034                 case DENY_NONE:
1035                         share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1036                         break;
1037
1038                 case DENY_DOS:
1039                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1040                         if (is_executable(fname)) {
1041                                 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1042                         } else {
1043                                 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1044                                         share_mode = FILE_SHARE_READ;
1045                                 } else {
1046                                         share_mode = FILE_SHARE_NONE;
1047                                 }
1048                         }
1049                         break;
1050
1051                 case DENY_FCB:
1052                         create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1053                         share_mode = FILE_SHARE_NONE;
1054                         break;
1055
1056                 default:
1057                         DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1058                                 (unsigned int)GET_DENY_MODE(deny_mode) ));
1059                         return False;
1060         }
1061
1062         DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1063                   "share_mode = 0x%x, create_disposition = 0x%x, "
1064                   "create_options = 0x%x\n",
1065                   fname,
1066                   (unsigned int)access_mask,
1067                   (unsigned int)share_mode,
1068                   (unsigned int)create_disposition,
1069                   (unsigned int)create_options ));
1070
1071         if (paccess_mask) {
1072                 *paccess_mask = access_mask;
1073         }
1074         if (pshare_mode) {
1075                 *pshare_mode = share_mode;
1076         }
1077         if (pcreate_disposition) {
1078                 *pcreate_disposition = create_disposition;
1079         }
1080         if (pcreate_options) {
1081                 *pcreate_options = create_options;
1082         }
1083
1084         return True;
1085
1086 }
1087
1088 static void schedule_defer_open(struct share_mode_lock *lck,
1089                                 struct timeval request_time,
1090                                 struct smb_request *req)
1091 {
1092         struct deferred_open_record state;
1093
1094         /* This is a relative time, added to the absolute
1095            request_time value to get the absolute timeout time.
1096            Note that if this is the second or greater time we enter
1097            this codepath for this particular request mid then
1098            request_time is left as the absolute time of the *first*
1099            time this request mid was processed. This is what allows
1100            the request to eventually time out. */
1101
1102         struct timeval timeout;
1103
1104         /* Normally the smbd we asked should respond within
1105          * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1106          * the client did, give twice the timeout as a safety
1107          * measure here in case the other smbd is stuck
1108          * somewhere else. */
1109
1110         timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1111
1112         /* Nothing actually uses state.delayed_for_oplocks
1113            but it's handy to differentiate in debug messages
1114            between a 30 second delay due to oplock break, and
1115            a 1 second delay for share mode conflicts. */
1116
1117         state.delayed_for_oplocks = True;
1118         state.id = lck->id;
1119
1120         if (!request_timed_out(request_time, timeout)) {
1121                 defer_open(lck, request_time, timeout, req, &state);
1122         }
1123 }
1124
1125 /****************************************************************************
1126  Open a file with a share mode.
1127 ****************************************************************************/
1128
1129 NTSTATUS open_file_ntcreate(connection_struct *conn,
1130                             struct smb_request *req,
1131                             const char *fname,
1132                             SMB_STRUCT_STAT *psbuf,
1133                             uint32 access_mask,         /* access bits (FILE_READ_DATA etc.) */
1134                             uint32 share_access,        /* share constants (FILE_SHARE_READ etc) */
1135                             uint32 create_disposition,  /* FILE_OPEN_IF etc. */
1136                             uint32 create_options,      /* options such as delete on close. */
1137                             uint32 new_dos_attributes,  /* attributes used for new file. */
1138                             int oplock_request,         /* internal Samba oplock codes. */
1139                                                         /* Information (FILE_EXISTS etc.) */
1140                             int *pinfo,
1141                             files_struct **result)
1142 {
1143         int flags=0;
1144         int flags2=0;
1145         bool file_existed = VALID_STAT(*psbuf);
1146         bool def_acl = False;
1147         bool posix_open = False;
1148         bool new_file_created = False;
1149         struct file_id id;
1150         NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1151         files_struct *fsp = NULL;
1152         mode_t new_unx_mode = (mode_t)0;
1153         mode_t unx_mode = (mode_t)0;
1154         int info;
1155         uint32 existing_dos_attributes = 0;
1156         struct pending_message_list *pml = NULL;
1157         struct timeval request_time = timeval_zero();
1158         struct share_mode_lock *lck = NULL;
1159         uint32 open_access_mask = access_mask;
1160         NTSTATUS status;
1161         int ret_flock;
1162         char *parent_dir;
1163         const char *newname;
1164
1165         ZERO_STRUCT(id);
1166
1167         if (conn->printer) {
1168                 /* 
1169                  * Printers are handled completely differently.
1170                  * Most of the passed parameters are ignored.
1171                  */
1172
1173                 if (pinfo) {
1174                         *pinfo = FILE_WAS_CREATED;
1175                 }
1176
1177                 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1178
1179                 return print_fsp_open(conn, fname, result);
1180         }
1181
1182         if (!parent_dirname_talloc(talloc_tos(), fname, &parent_dir,
1183                                    &newname)) {
1184                 return NT_STATUS_NO_MEMORY;
1185         }
1186
1187         if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1188                 posix_open = True;
1189                 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1190                 new_dos_attributes = 0;
1191         } else {
1192                 /* We add aARCH to this as this mode is only used if the file is
1193                  * created new. */
1194                 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1195                                      parent_dir);
1196         }
1197
1198         DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1199                    "access_mask=0x%x share_access=0x%x "
1200                    "create_disposition = 0x%x create_options=0x%x "
1201                    "unix mode=0%o oplock_request=%d\n",
1202                    fname, new_dos_attributes, access_mask, share_access,
1203                    create_disposition, create_options, unx_mode,
1204                    oplock_request));
1205
1206         if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1207                 DEBUG(0, ("No smb request but not an internal only open!\n"));
1208                 return NT_STATUS_INTERNAL_ERROR;
1209         }
1210
1211         /*
1212          * Only non-internal opens can be deferred at all
1213          */
1214
1215         if ((req != NULL)
1216             && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1217                 struct deferred_open_record *state =
1218                         (struct deferred_open_record *)pml->private_data.data;
1219
1220                 /* Remember the absolute time of the original
1221                    request with this mid. We'll use it later to
1222                    see if this has timed out. */
1223
1224                 request_time = pml->request_time;
1225
1226                 /* Remove the deferred open entry under lock. */
1227                 lck = get_share_mode_lock(NULL, state->id, NULL, NULL);
1228                 if (lck == NULL) {
1229                         DEBUG(0, ("could not get share mode lock\n"));
1230                 } else {
1231                         del_deferred_open_entry(lck, req->mid);
1232                         TALLOC_FREE(lck);
1233                 }
1234
1235                 /* Ensure we don't reprocess this message. */
1236                 remove_deferred_open_smb_message(req->mid);
1237         }
1238
1239         status = check_name(conn, fname);
1240         if (!NT_STATUS_IS_OK(status)) {
1241                 return status;
1242         } 
1243
1244         if (!posix_open) {
1245                 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1246                 if (file_existed) {
1247                         existing_dos_attributes = dos_mode(conn, fname, psbuf);
1248                 }
1249         }
1250
1251         /* ignore any oplock requests if oplocks are disabled */
1252         if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1253             IS_VETO_OPLOCK_PATH(conn, fname)) {
1254                 /* Mask off everything except the private Samba bits. */
1255                 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1256         }
1257
1258         /* this is for OS/2 long file names - say we don't support them */
1259         if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1260                 /* OS/2 Workplace shell fix may be main code stream in a later
1261                  * release. */
1262                 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1263                          "supported.\n"));
1264                 if (use_nt_status()) {
1265                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1266                 }
1267                 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1268         }
1269
1270         switch( create_disposition ) {
1271                 /*
1272                  * Currently we're using FILE_SUPERSEDE as the same as
1273                  * FILE_OVERWRITE_IF but they really are
1274                  * different. FILE_SUPERSEDE deletes an existing file
1275                  * (requiring delete access) then recreates it.
1276                  */
1277                 case FILE_SUPERSEDE:
1278                         /* If file exists replace/overwrite. If file doesn't
1279                          * exist create. */
1280                         flags2 |= (O_CREAT | O_TRUNC);
1281                         break;
1282
1283                 case FILE_OVERWRITE_IF:
1284                         /* If file exists replace/overwrite. If file doesn't
1285                          * exist create. */
1286                         flags2 |= (O_CREAT | O_TRUNC);
1287                         break;
1288
1289                 case FILE_OPEN:
1290                         /* If file exists open. If file doesn't exist error. */
1291                         if (!file_existed) {
1292                                 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1293                                          "requested for file %s and file "
1294                                          "doesn't exist.\n", fname ));
1295                                 errno = ENOENT;
1296                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1297                         }
1298                         break;
1299
1300                 case FILE_OVERWRITE:
1301                         /* If file exists overwrite. If file doesn't exist
1302                          * error. */
1303                         if (!file_existed) {
1304                                 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1305                                          "requested for file %s and file "
1306                                          "doesn't exist.\n", fname ));
1307                                 errno = ENOENT;
1308                                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1309                         }
1310                         flags2 |= O_TRUNC;
1311                         break;
1312
1313                 case FILE_CREATE:
1314                         /* If file exists error. If file doesn't exist
1315                          * create. */
1316                         if (file_existed) {
1317                                 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1318                                          "requested for file %s and file "
1319                                          "already exists.\n", fname ));
1320                                 if (S_ISDIR(psbuf->st_mode)) {
1321                                         errno = EISDIR;
1322                                 } else {
1323                                         errno = EEXIST;
1324                                 }
1325                                 return map_nt_error_from_unix(errno);
1326                         }
1327                         flags2 |= (O_CREAT|O_EXCL);
1328                         break;
1329
1330                 case FILE_OPEN_IF:
1331                         /* If file exists open. If file doesn't exist
1332                          * create. */
1333                         flags2 |= O_CREAT;
1334                         break;
1335
1336                 default:
1337                         return NT_STATUS_INVALID_PARAMETER;
1338         }
1339
1340         /* We only care about matching attributes on file exists and
1341          * overwrite. */
1342
1343         if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1344                              (create_disposition == FILE_OVERWRITE_IF))) {
1345                 if (!open_match_attributes(conn, fname,
1346                                            existing_dos_attributes,
1347                                            new_dos_attributes, psbuf->st_mode,
1348                                            unx_mode, &new_unx_mode)) {
1349                         DEBUG(5,("open_file_ntcreate: attributes missmatch "
1350                                  "for file %s (%x %x) (0%o, 0%o)\n",
1351                                  fname, existing_dos_attributes,
1352                                  new_dos_attributes,
1353                                  (unsigned int)psbuf->st_mode,
1354                                  (unsigned int)unx_mode ));
1355                         errno = EACCES;
1356                         return NT_STATUS_ACCESS_DENIED;
1357                 }
1358         }
1359
1360         /* This is a nasty hack - must fix... JRA. */
1361         if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1362                 open_access_mask = access_mask = FILE_GENERIC_ALL;
1363         }
1364
1365         /*
1366          * Convert GENERIC bits to specific bits.
1367          */
1368
1369         se_map_generic(&access_mask, &file_generic_mapping);
1370         open_access_mask = access_mask;
1371
1372         if (flags2 & O_TRUNC) {
1373                 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1374         }
1375
1376         DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1377                    "access_mask=0x%x\n", fname, access_mask ));
1378
1379         /*
1380          * Note that we ignore the append flag as append does not
1381          * mean the same thing under DOS and Unix.
1382          */
1383
1384         if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1385                 /* DENY_DOS opens are always underlying read-write on the
1386                    file handle, no matter what the requested access mask
1387                     says. */
1388                 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1389                         access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1390                         flags = O_RDWR;
1391                 } else {
1392                         flags = O_WRONLY;
1393                 }
1394         } else {
1395                 flags = O_RDONLY;
1396         }
1397
1398         /*
1399          * Currently we only look at FILE_WRITE_THROUGH for create options.
1400          */
1401
1402 #if defined(O_SYNC)
1403         if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1404                 flags2 |= O_SYNC;
1405         }
1406 #endif /* O_SYNC */
1407   
1408         if (posix_open & (access_mask & FILE_APPEND_DATA)) {
1409                 flags2 |= O_APPEND;
1410         }
1411
1412         if (!posix_open && !CAN_WRITE(conn)) {
1413                 /*
1414                  * We should really return a permission denied error if either
1415                  * O_CREAT or O_TRUNC are set, but for compatibility with
1416                  * older versions of Samba we just AND them out.
1417                  */
1418                 flags2 &= ~(O_CREAT|O_TRUNC);
1419         }
1420
1421         /*
1422          * Ensure we can't write on a read-only share or file.
1423          */
1424
1425         if (flags != O_RDONLY && file_existed &&
1426             (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1427                 DEBUG(5,("open_file_ntcreate: write access requested for "
1428                          "file %s on read only %s\n",
1429                          fname, !CAN_WRITE(conn) ? "share" : "file" ));
1430                 errno = EACCES;
1431                 return NT_STATUS_ACCESS_DENIED;
1432         }
1433
1434         status = file_new(conn, &fsp);
1435         if(!NT_STATUS_IS_OK(status)) {
1436                 return status;
1437         }
1438
1439         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
1440         fsp->share_access = share_access;
1441         fsp->fh->private_options = create_options;
1442         fsp->access_mask = open_access_mask; /* We change this to the
1443                                               * requested access_mask after
1444                                               * the open is done. */
1445         fsp->posix_open = posix_open;
1446
1447         /* Ensure no SAMBA_PRIVATE bits can be set. */
1448         fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1449
1450         if (timeval_is_zero(&request_time)) {
1451                 request_time = fsp->open_time;
1452         }
1453
1454         if (file_existed) {
1455                 id = vfs_file_id_from_sbuf(conn, psbuf);
1456
1457                 lck = get_share_mode_lock(NULL, id,
1458                                           conn->connectpath,
1459                                           fname);
1460
1461                 if (lck == NULL) {
1462                         file_free(fsp);
1463                         DEBUG(0, ("Could not get share mode lock\n"));
1464                         return NT_STATUS_SHARING_VIOLATION;
1465                 }
1466
1467                 /* First pass - send break only on batch oplocks. */
1468                 if ((req != NULL)
1469                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1470                                          oplock_request)) {
1471                         schedule_defer_open(lck, request_time, req);
1472                         TALLOC_FREE(lck);
1473                         file_free(fsp);
1474                         return NT_STATUS_SHARING_VIOLATION;
1475                 }
1476
1477                 /* Use the client requested access mask here, not the one we
1478                  * open with. */
1479                 status = open_mode_check(conn, fname, lck,
1480                                          access_mask, share_access,
1481                                          create_options, &file_existed);
1482
1483                 if (NT_STATUS_IS_OK(status)) {
1484                         /* We might be going to allow this open. Check oplock
1485                          * status again. */
1486                         /* Second pass - send break for both batch or
1487                          * exclusive oplocks. */
1488                         if ((req != NULL)
1489                              && delay_for_oplocks(lck, fsp, req->mid, 2,
1490                                                   oplock_request)) {
1491                                 schedule_defer_open(lck, request_time, req);
1492                                 TALLOC_FREE(lck);
1493                                 file_free(fsp);
1494                                 return NT_STATUS_SHARING_VIOLATION;
1495                         }
1496                 }
1497
1498                 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1499                         /* DELETE_PENDING is not deferred for a second */
1500                         TALLOC_FREE(lck);
1501                         file_free(fsp);
1502                         return status;
1503                 }
1504
1505                 if (!NT_STATUS_IS_OK(status)) {
1506                         uint32 can_access_mask;
1507                         bool can_access = True;
1508
1509                         SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1510
1511                         /* Check if this can be done with the deny_dos and fcb
1512                          * calls. */
1513                         if (create_options &
1514                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1515                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1516                                 files_struct *fsp_dup;
1517
1518                                 if (req == NULL) {
1519                                         DEBUG(0, ("DOS open without an SMB "
1520                                                   "request!\n"));
1521                                         TALLOC_FREE(lck);
1522                                         file_free(fsp);
1523                                         return NT_STATUS_INTERNAL_ERROR;
1524                                 }
1525
1526                                 /* Use the client requested access mask here,
1527                                  * not the one we open with. */
1528                                 fsp_dup = fcb_or_dos_open(conn, fname, id,
1529                                                           req->smbpid,
1530                                                           req->vuid,
1531                                                           access_mask,
1532                                                           share_access,
1533                                                           create_options);
1534
1535                                 if (fsp_dup) {
1536                                         TALLOC_FREE(lck);
1537                                         file_free(fsp);
1538                                         if (pinfo) {
1539                                                 *pinfo = FILE_WAS_OPENED;
1540                                         }
1541                                         conn->num_files_open++;
1542                                         *result = fsp_dup;
1543                                         return NT_STATUS_OK;
1544                                 }
1545                         }
1546
1547                         /*
1548                          * This next line is a subtlety we need for
1549                          * MS-Access. If a file open will fail due to share
1550                          * permissions and also for security (access) reasons,
1551                          * we need to return the access failed error, not the
1552                          * share error. We can't open the file due to kernel
1553                          * oplock deadlock (it's possible we failed above on
1554                          * the open_mode_check()) so use a userspace check.
1555                          */
1556
1557                         if (flags & O_RDWR) {
1558                                 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1559                         } else if (flags & O_WRONLY) {
1560                                 can_access_mask = FILE_WRITE_DATA;
1561                         } else {
1562                                 can_access_mask = FILE_READ_DATA;
1563                         }
1564
1565                         if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1566                             !can_access_file(conn,fname,psbuf,can_access_mask)) {
1567                                 can_access = False;
1568                         }
1569
1570                         /* 
1571                          * If we're returning a share violation, ensure we
1572                          * cope with the braindead 1 second delay.
1573                          */
1574
1575                         if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1576                             lp_defer_sharing_violations()) {
1577                                 struct timeval timeout;
1578                                 struct deferred_open_record state;
1579                                 int timeout_usecs;
1580
1581                                 /* this is a hack to speed up torture tests
1582                                    in 'make test' */
1583                                 timeout_usecs = lp_parm_int(SNUM(conn),
1584                                                             "smbd","sharedelay",
1585                                                             SHARING_VIOLATION_USEC_WAIT);
1586
1587                                 /* This is a relative time, added to the absolute
1588                                    request_time value to get the absolute timeout time.
1589                                    Note that if this is the second or greater time we enter
1590                                    this codepath for this particular request mid then
1591                                    request_time is left as the absolute time of the *first*
1592                                    time this request mid was processed. This is what allows
1593                                    the request to eventually time out. */
1594
1595                                 timeout = timeval_set(0, timeout_usecs);
1596
1597                                 /* Nothing actually uses state.delayed_for_oplocks
1598                                    but it's handy to differentiate in debug messages
1599                                    between a 30 second delay due to oplock break, and
1600                                    a 1 second delay for share mode conflicts. */
1601
1602                                 state.delayed_for_oplocks = False;
1603                                 state.id = id;
1604
1605                                 if ((req != NULL)
1606                                     && !request_timed_out(request_time,
1607                                                           timeout)) {
1608                                         defer_open(lck, request_time, timeout,
1609                                                    req, &state);
1610                                 }
1611                         }
1612
1613                         TALLOC_FREE(lck);
1614                         if (can_access) {
1615                                 /*
1616                                  * We have detected a sharing violation here
1617                                  * so return the correct error code
1618                                  */
1619                                 status = NT_STATUS_SHARING_VIOLATION;
1620                         } else {
1621                                 status = NT_STATUS_ACCESS_DENIED;
1622                         }
1623                         file_free(fsp);
1624                         return status;
1625                 }
1626
1627                 /*
1628                  * We exit this block with the share entry *locked*.....
1629                  */
1630         }
1631
1632         SMB_ASSERT(!file_existed || (lck != NULL));
1633
1634         /*
1635          * Ensure we pay attention to default ACLs on directories if required.
1636          */
1637
1638         if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1639             (def_acl = directory_has_default_acl(conn, parent_dir))) {
1640                 unx_mode = 0777;
1641         }
1642
1643         DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1644                 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1645                  (unsigned int)flags, (unsigned int)flags2,
1646                  (unsigned int)unx_mode, (unsigned int)access_mask,
1647                  (unsigned int)open_access_mask));
1648
1649         /*
1650          * open_file strips any O_TRUNC flags itself.
1651          */
1652
1653         fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1654                              flags|flags2, unx_mode, access_mask,
1655                              open_access_mask);
1656
1657         if (!NT_STATUS_IS_OK(fsp_open)) {
1658                 if (lck != NULL) {
1659                         TALLOC_FREE(lck);
1660                 }
1661                 file_free(fsp);
1662                 return fsp_open;
1663         }
1664
1665         if (!file_existed) {
1666
1667                 /*
1668                  * Deal with the race condition where two smbd's detect the
1669                  * file doesn't exist and do the create at the same time. One
1670                  * of them will win and set a share mode, the other (ie. this
1671                  * one) should check if the requested share mode for this
1672                  * create is allowed.
1673                  */
1674
1675                 /*
1676                  * Now the file exists and fsp is successfully opened,
1677                  * fsp->dev and fsp->inode are valid and should replace the
1678                  * dev=0,inode=0 from a non existent file. Spotted by
1679                  * Nadav Danieli <nadavd@exanet.com>. JRA.
1680                  */
1681
1682                 id = fsp->file_id;
1683
1684                 lck = get_share_mode_lock(NULL, id,
1685                                           conn->connectpath,
1686                                           fname);
1687
1688                 if (lck == NULL) {
1689                         DEBUG(0, ("open_file_ntcreate: Could not get share "
1690                                   "mode lock for %s\n", fname));
1691                         fd_close(conn, fsp);
1692                         file_free(fsp);
1693                         return NT_STATUS_SHARING_VIOLATION;
1694                 }
1695
1696                 /* First pass - send break only on batch oplocks. */
1697                 if ((req != NULL)
1698                     && delay_for_oplocks(lck, fsp, req->mid, 1,
1699                                          oplock_request)) {
1700                         schedule_defer_open(lck, request_time, req);
1701                         TALLOC_FREE(lck);
1702                         fd_close(conn, fsp);
1703                         file_free(fsp);
1704                         return NT_STATUS_SHARING_VIOLATION;
1705                 }
1706
1707                 status = open_mode_check(conn, fname, lck,
1708                                          access_mask, share_access,
1709                                          create_options, &file_existed);
1710
1711                 if (NT_STATUS_IS_OK(status)) {
1712                         /* We might be going to allow this open. Check oplock
1713                          * status again. */
1714                         /* Second pass - send break for both batch or
1715                          * exclusive oplocks. */
1716                         if ((req != NULL)
1717                             && delay_for_oplocks(lck, fsp, req->mid, 2,
1718                                                  oplock_request)) {
1719                                 schedule_defer_open(lck, request_time, req);
1720                                 TALLOC_FREE(lck);
1721                                 fd_close(conn, fsp);
1722                                 file_free(fsp);
1723                                 return NT_STATUS_SHARING_VIOLATION;
1724                         }
1725                 }
1726
1727                 if (!NT_STATUS_IS_OK(status)) {
1728                         struct deferred_open_record state;
1729
1730                         fd_close(conn, fsp);
1731                         file_free(fsp);
1732
1733                         state.delayed_for_oplocks = False;
1734                         state.id = id;
1735
1736                         /* Do it all over again immediately. In the second
1737                          * round we will find that the file existed and handle
1738                          * the DELETE_PENDING and FCB cases correctly. No need
1739                          * to duplicate the code here. Essentially this is a
1740                          * "goto top of this function", but don't tell
1741                          * anybody... */
1742
1743                         if (req != NULL) {
1744                                 defer_open(lck, request_time, timeval_zero(),
1745                                            req, &state);
1746                         }
1747                         TALLOC_FREE(lck);
1748                         return status;
1749                 }
1750
1751                 /*
1752                  * We exit this block with the share entry *locked*.....
1753                  */
1754
1755         }
1756
1757         SMB_ASSERT(lck != NULL);
1758
1759         /* note that we ignore failure for the following. It is
1760            basically a hack for NFS, and NFS will never set one of
1761            these only read them. Nobody but Samba can ever set a deny
1762            mode and we have already checked our more authoritative
1763            locking database for permission to set this deny mode. If
1764            the kernel refuses the operations then the kernel is wrong.
1765            note that GPFS supports it as well - jmcd */
1766
1767         ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1768         if(ret_flock == -1 ){
1769
1770                 TALLOC_FREE(lck);
1771                 fd_close(conn, fsp);
1772                 file_free(fsp);
1773                 
1774                 return NT_STATUS_SHARING_VIOLATION;
1775         }
1776
1777         /*
1778          * At this point onwards, we can guarentee that the share entry
1779          * is locked, whether we created the file or not, and that the
1780          * deny mode is compatible with all current opens.
1781          */
1782
1783         /*
1784          * If requested, truncate the file.
1785          */
1786
1787         if (flags2&O_TRUNC) {
1788                 /*
1789                  * We are modifing the file after open - update the stat
1790                  * struct..
1791                  */
1792                 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1793                     (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1794                         status = map_nt_error_from_unix(errno);
1795                         TALLOC_FREE(lck);
1796                         fd_close(conn,fsp);
1797                         file_free(fsp);
1798                         return status;
1799                 }
1800         }
1801
1802         /* Record the options we were opened with. */
1803         fsp->share_access = share_access;
1804         fsp->fh->private_options = create_options;
1805         fsp->access_mask = access_mask;
1806
1807         if (file_existed) {
1808                 /* stat opens on existing files don't get oplocks. */
1809                 if (is_stat_open(open_access_mask)) {
1810                         fsp->oplock_type = NO_OPLOCK;
1811                 }
1812
1813                 if (!(flags2 & O_TRUNC)) {
1814                         info = FILE_WAS_OPENED;
1815                 } else {
1816                         info = FILE_WAS_OVERWRITTEN;
1817                 }
1818         } else {
1819                 info = FILE_WAS_CREATED;
1820         }
1821
1822         if (pinfo) {
1823                 *pinfo = info;
1824         }
1825
1826         /* 
1827          * Setup the oplock info in both the shared memory and
1828          * file structs.
1829          */
1830
1831         if ((fsp->oplock_type != NO_OPLOCK) &&
1832             (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1833                 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1834                         /* Could not get the kernel oplock */
1835                         fsp->oplock_type = NO_OPLOCK;
1836                 }
1837         }
1838
1839         if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
1840                 new_file_created = True;
1841         }
1842
1843         set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type, new_file_created);
1844
1845         /* Handle strange delete on close create semantics. */
1846         if ((create_options & FILE_DELETE_ON_CLOSE) && can_set_initial_delete_on_close(lck)) {
1847                 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1848
1849                 if (!NT_STATUS_IS_OK(status)) {
1850                         /* Remember to delete the mode we just added. */
1851                         del_share_mode(lck, fsp);
1852                         TALLOC_FREE(lck);
1853                         fd_close(conn,fsp);
1854                         file_free(fsp);
1855                         return status;
1856                 }
1857                 /* Note that here we set the *inital* delete on close flag,
1858                    not the regular one. The magic gets handled in close. */
1859                 fsp->initial_delete_on_close = True;
1860         }
1861         
1862         if (new_file_created) {
1863                 /* Files should be initially set as archive */
1864                 if (lp_map_archive(SNUM(conn)) ||
1865                     lp_store_dos_attributes(SNUM(conn))) {
1866                         if (!posix_open) {
1867                                 file_set_dosmode(conn, fname,
1868                                          new_dos_attributes | aARCH, NULL,
1869                                          parent_dir,
1870                                          true);
1871                         }
1872                 }
1873         }
1874
1875         /*
1876          * Take care of inherited ACLs on created files - if default ACL not
1877          * selected.
1878          */
1879
1880         if (!posix_open && !file_existed && !def_acl) {
1881
1882                 int saved_errno = errno; /* We might get ENOSYS in the next
1883                                           * call.. */
1884
1885                 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1886                     errno == ENOSYS) {
1887                         errno = saved_errno; /* Ignore ENOSYS */
1888                 }
1889
1890         } else if (new_unx_mode) {
1891
1892                 int ret = -1;
1893
1894                 /* Attributes need changing. File already existed. */
1895
1896                 {
1897                         int saved_errno = errno; /* We might get ENOSYS in the
1898                                                   * next call.. */
1899                         ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1900                                                  new_unx_mode);
1901
1902                         if (ret == -1 && errno == ENOSYS) {
1903                                 errno = saved_errno; /* Ignore ENOSYS */
1904                         } else {
1905                                 DEBUG(5, ("open_file_ntcreate: reset "
1906                                           "attributes of file %s to 0%o\n",
1907                                           fname, (unsigned int)new_unx_mode));
1908                                 ret = 0; /* Don't do the fchmod below. */
1909                         }
1910                 }
1911
1912                 if ((ret == -1) &&
1913                     (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1914                         DEBUG(5, ("open_file_ntcreate: failed to reset "
1915                                   "attributes of file %s to 0%o\n",
1916                                   fname, (unsigned int)new_unx_mode));
1917         }
1918
1919         /* If this is a successful open, we must remove any deferred open
1920          * records. */
1921         if (req != NULL) {
1922                 del_deferred_open_entry(lck, req->mid);
1923         }
1924         TALLOC_FREE(lck);
1925
1926         conn->num_files_open++;
1927
1928         *result = fsp;
1929         return NT_STATUS_OK;
1930 }
1931
1932 /****************************************************************************
1933  Open a file for for write to ensure that we can fchmod it.
1934 ****************************************************************************/
1935
1936 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1937                           SMB_STRUCT_STAT *psbuf, files_struct **result)
1938 {
1939         files_struct *fsp = NULL;
1940         NTSTATUS status;
1941
1942         if (!VALID_STAT(*psbuf)) {
1943                 return NT_STATUS_INVALID_PARAMETER;
1944         }
1945
1946         status = file_new(conn, &fsp);
1947         if(!NT_STATUS_IS_OK(status)) {
1948                 return status;
1949         }
1950
1951         /* note! we must use a non-zero desired access or we don't get
1952            a real file descriptor. Oh what a twisted web we weave. */
1953         status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
1954                            0, FILE_WRITE_DATA, FILE_WRITE_DATA);
1955
1956         /* 
1957          * This is not a user visible file open.
1958          * Don't set a share mode and don't increment
1959          * the conn->num_files_open.
1960          */
1961
1962         if (!NT_STATUS_IS_OK(status)) {
1963                 file_free(fsp);
1964                 return status;
1965         }
1966
1967         *result = fsp;
1968         return NT_STATUS_OK;
1969 }
1970
1971 /****************************************************************************
1972  Close the fchmod file fd - ensure no locks are lost.
1973 ****************************************************************************/
1974
1975 NTSTATUS close_file_fchmod(files_struct *fsp)
1976 {
1977         NTSTATUS status = fd_close(fsp->conn, fsp);
1978         file_free(fsp);
1979         return status;
1980 }
1981
1982 static NTSTATUS mkdir_internal(connection_struct *conn,
1983                                 const char *name,
1984                                 uint32 file_attributes,
1985                                 SMB_STRUCT_STAT *psbuf)
1986 {
1987         mode_t mode;
1988         char *parent_dir;
1989         const char *dirname;
1990         NTSTATUS status;
1991         bool posix_open = false;
1992
1993         if(!CAN_WRITE(conn)) {
1994                 DEBUG(5,("mkdir_internal: failing create on read-only share "
1995                          "%s\n", lp_servicename(SNUM(conn))));
1996                 return NT_STATUS_ACCESS_DENIED;
1997         }
1998
1999         status = check_name(conn, name);
2000         if (!NT_STATUS_IS_OK(status)) {
2001                 return status;
2002         }
2003
2004         if (!parent_dirname_talloc(talloc_tos(), name, &parent_dir,
2005                                    &dirname)) {
2006                 return NT_STATUS_NO_MEMORY;
2007         }
2008
2009         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2010                 posix_open = true;
2011                 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2012         } else {
2013                 mode = unix_mode(conn, aDIR, name, parent_dir);
2014         }
2015
2016         if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
2017                 return map_nt_error_from_unix(errno);
2018         }
2019
2020         /* Ensure we're checking for a symlink here.... */
2021         /* We don't want to get caught by a symlink racer. */
2022
2023         if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2024                 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2025                           name, strerror(errno)));
2026                 return map_nt_error_from_unix(errno);
2027         }
2028
2029         if (!S_ISDIR(psbuf->st_mode)) {
2030                 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2031                           name));
2032                 return NT_STATUS_ACCESS_DENIED;
2033         }
2034
2035         if (lp_store_dos_attributes(SNUM(conn))) {
2036                 if (!posix_open) {
2037                         file_set_dosmode(conn, name,
2038                                  file_attributes | aDIR, NULL,
2039                                  parent_dir,
2040                                  true);
2041                 }
2042         }
2043
2044         if (lp_inherit_perms(SNUM(conn))) {
2045                 inherit_access_acl(conn, parent_dir, name, mode);
2046         }
2047
2048         if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2049                 /*
2050                  * Check if high bits should have been set,
2051                  * then (if bits are missing): add them.
2052                  * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2053                  * dir.
2054                  */
2055                 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2056                         SMB_VFS_CHMOD(conn, name,
2057                                       psbuf->st_mode | (mode & ~psbuf->st_mode));
2058                 }
2059         }
2060
2061         /* Change the owner if required. */
2062         if (lp_inherit_owner(SNUM(conn))) {
2063                 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2064         }
2065
2066         notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2067                      name);
2068
2069         return NT_STATUS_OK;
2070 }
2071
2072 /****************************************************************************
2073  Open a directory from an NT SMB call.
2074 ****************************************************************************/
2075
2076 NTSTATUS open_directory(connection_struct *conn,
2077                         struct smb_request *req,
2078                         const char *fname,
2079                         SMB_STRUCT_STAT *psbuf,
2080                         uint32 access_mask,
2081                         uint32 share_access,
2082                         uint32 create_disposition,
2083                         uint32 create_options,
2084                         uint32 file_attributes,
2085                         int *pinfo,
2086                         files_struct **result)
2087 {
2088         files_struct *fsp = NULL;
2089         bool dir_existed = VALID_STAT(*psbuf) ? True : False;
2090         struct share_mode_lock *lck = NULL;
2091         NTSTATUS status;
2092         int info = 0;
2093
2094         DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2095                  "share_access = 0x%x create_options = 0x%x, "
2096                  "create_disposition = 0x%x, file_attributes = 0x%x\n",
2097                  fname,
2098                  (unsigned int)access_mask,
2099                  (unsigned int)share_access,
2100                  (unsigned int)create_options,
2101                  (unsigned int)create_disposition,
2102                  (unsigned int)file_attributes));
2103
2104         if (is_ntfs_stream_name(fname)) {
2105                 DEBUG(2, ("open_directory: %s is a stream name!\n", fname));
2106                 return NT_STATUS_NOT_A_DIRECTORY;
2107         }
2108
2109         switch( create_disposition ) {
2110                 case FILE_OPEN:
2111
2112                         info = FILE_WAS_OPENED;
2113
2114                         /*
2115                          * We want to follow symlinks here.
2116                          */
2117
2118                         if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2119                                 return map_nt_error_from_unix(errno);
2120                         }
2121                                 
2122                         break;
2123
2124                 case FILE_CREATE:
2125
2126                         /* If directory exists error. If directory doesn't
2127                          * exist create. */
2128
2129                         status = mkdir_internal(conn,
2130                                                 fname,
2131                                                 file_attributes,
2132                                                 psbuf);
2133
2134                         if (!NT_STATUS_IS_OK(status)) {
2135                                 DEBUG(2, ("open_directory: unable to create "
2136                                           "%s. Error was %s\n", fname,
2137                                           nt_errstr(status)));
2138                                 return status;
2139                         }
2140
2141                         info = FILE_WAS_CREATED;
2142                         break;
2143
2144                 case FILE_OPEN_IF:
2145                         /*
2146                          * If directory exists open. If directory doesn't
2147                          * exist create.
2148                          */
2149
2150                         status = mkdir_internal(conn,
2151                                                 fname,
2152                                                 file_attributes,
2153                                                 psbuf);
2154
2155                         if (NT_STATUS_IS_OK(status)) {
2156                                 info = FILE_WAS_CREATED;
2157                         }
2158
2159                         if (NT_STATUS_EQUAL(status,
2160                                             NT_STATUS_OBJECT_NAME_COLLISION)) {
2161                                 info = FILE_WAS_OPENED;
2162                                 status = NT_STATUS_OK;
2163                         }
2164                                 
2165                         break;
2166
2167                 case FILE_SUPERSEDE:
2168                 case FILE_OVERWRITE:
2169                 case FILE_OVERWRITE_IF:
2170                 default:
2171                         DEBUG(5,("open_directory: invalid create_disposition "
2172                                  "0x%x for directory %s\n",
2173                                  (unsigned int)create_disposition, fname));
2174                         return NT_STATUS_INVALID_PARAMETER;
2175         }
2176
2177         if(!S_ISDIR(psbuf->st_mode)) {
2178                 DEBUG(5,("open_directory: %s is not a directory !\n",
2179                          fname ));
2180                 return NT_STATUS_NOT_A_DIRECTORY;
2181         }
2182
2183         status = file_new(conn, &fsp);
2184         if(!NT_STATUS_IS_OK(status)) {
2185                 return status;
2186         }
2187
2188         /*
2189          * Setup the files_struct for it.
2190          */
2191         
2192         fsp->mode = psbuf->st_mode;
2193         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2194         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2195         fsp->file_pid = req ? req->smbpid : 0;
2196         fsp->can_lock = False;
2197         fsp->can_read = False;
2198         fsp->can_write = False;
2199
2200         fsp->share_access = share_access;
2201         fsp->fh->private_options = create_options;
2202         fsp->access_mask = access_mask;
2203
2204         fsp->print_file = False;
2205         fsp->modified = False;
2206         fsp->oplock_type = NO_OPLOCK;
2207         fsp->sent_oplock_break = NO_BREAK_SENT;
2208         fsp->is_directory = True;
2209         fsp->is_stat = False;
2210         fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2211
2212         string_set(&fsp->fsp_name,fname);
2213
2214         lck = get_share_mode_lock(NULL, fsp->file_id,
2215                                   conn->connectpath,
2216                                   fname);
2217
2218         if (lck == NULL) {
2219                 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2220                 file_free(fsp);
2221                 return NT_STATUS_SHARING_VIOLATION;
2222         }
2223
2224         status = open_mode_check(conn, fname, lck,
2225                                 access_mask, share_access,
2226                                 create_options, &dir_existed);
2227
2228         if (!NT_STATUS_IS_OK(status)) {
2229                 TALLOC_FREE(lck);
2230                 file_free(fsp);
2231                 return status;
2232         }
2233
2234         set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK, True);
2235
2236         /* For directories the delete on close bit at open time seems
2237            always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2238         if (create_options & FILE_DELETE_ON_CLOSE) {
2239                 status = can_set_delete_on_close(fsp, True, 0);
2240                 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2241                         TALLOC_FREE(lck);
2242                         file_free(fsp);
2243                         return status;
2244                 }
2245
2246                 if (NT_STATUS_IS_OK(status)) {
2247                         /* Note that here we set the *inital* delete on close flag,
2248                            not the regular one. The magic gets handled in close. */
2249                         fsp->initial_delete_on_close = True;
2250                 }
2251         }
2252
2253         TALLOC_FREE(lck);
2254
2255         if (pinfo) {
2256                 *pinfo = info;
2257         }
2258
2259         conn->num_files_open++;
2260
2261         *result = fsp;
2262         return NT_STATUS_OK;
2263 }
2264
2265 NTSTATUS create_directory(connection_struct *conn, const char *directory)
2266 {
2267         NTSTATUS status;
2268         SMB_STRUCT_STAT sbuf;
2269         files_struct *fsp;
2270
2271         SET_STAT_INVALID(sbuf);
2272         
2273         status = open_directory(conn, NULL, directory, &sbuf,
2274                                 FILE_READ_ATTRIBUTES, /* Just a stat open */
2275                                 FILE_SHARE_NONE, /* Ignored for stat opens */
2276                                 FILE_CREATE,
2277                                 0,
2278                                 FILE_ATTRIBUTE_DIRECTORY,
2279                                 NULL,
2280                                 &fsp);
2281
2282         if (NT_STATUS_IS_OK(status)) {
2283                 close_file(fsp, NORMAL_CLOSE);
2284         }
2285
2286         return status;
2287 }
2288
2289 /****************************************************************************
2290  Open a pseudo-file (no locking checks - a 'stat' open).
2291 ****************************************************************************/
2292
2293 NTSTATUS open_file_stat(connection_struct *conn, struct smb_request *req,
2294                         const char *fname, SMB_STRUCT_STAT *psbuf,
2295                         files_struct **result)
2296 {
2297         files_struct *fsp = NULL;
2298         NTSTATUS status;
2299
2300         if (!VALID_STAT(*psbuf)) {
2301                 return NT_STATUS_INVALID_PARAMETER;
2302         }
2303
2304         /* Can't 'stat' open directories. */
2305         if(S_ISDIR(psbuf->st_mode)) {
2306                 return NT_STATUS_FILE_IS_A_DIRECTORY;
2307         }
2308
2309         status = file_new(conn, &fsp);
2310         if(!NT_STATUS_IS_OK(status)) {
2311                 return status;
2312         }
2313
2314         DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2315
2316         /*
2317          * Setup the files_struct for it.
2318          */
2319         
2320         fsp->mode = psbuf->st_mode;
2321         fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2322         fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2323         fsp->file_pid = req ? req->smbpid : 0;
2324         fsp->can_lock = False;
2325         fsp->can_read = False;
2326         fsp->can_write = False;
2327         fsp->print_file = False;
2328         fsp->modified = False;
2329         fsp->oplock_type = NO_OPLOCK;
2330         fsp->sent_oplock_break = NO_BREAK_SENT;
2331         fsp->is_directory = False;
2332         fsp->is_stat = True;
2333         string_set(&fsp->fsp_name,fname);
2334
2335         conn->num_files_open++;
2336
2337         *result = fsp;
2338         return NT_STATUS_OK;
2339 }
2340
2341 /****************************************************************************
2342  Receive notification that one of our open files has been renamed by another
2343  smbd process.
2344 ****************************************************************************/
2345
2346 void msg_file_was_renamed(struct messaging_context *msg,
2347                           void *private_data,
2348                           uint32_t msg_type,
2349                           struct server_id server_id,
2350                           DATA_BLOB *data)
2351 {
2352         files_struct *fsp;
2353         char *frm = (char *)data->data;
2354         struct file_id id;
2355         const char *sharepath;
2356         const char *newname;
2357         size_t sp_len;
2358
2359         if (data->data == NULL
2360             || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2361                 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2362                           (int)data->length));
2363                 return;
2364         }
2365
2366         /* Unpack the message. */
2367         pull_file_id_16(frm, &id);
2368         sharepath = &frm[16];
2369         newname = sharepath + strlen(sharepath) + 1;
2370         sp_len = strlen(sharepath);
2371
2372         DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2373                 "file_id %s\n",
2374                   sharepath, newname, file_id_string_tos(&id)));
2375
2376         for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2377                 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2378                         DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2379                                 fsp->fnum, fsp->fsp_name, newname ));
2380                         string_set(&fsp->fsp_name, newname);
2381                 } else {
2382                         /* TODO. JRA. */
2383                         /* Now we have the complete path we can work out if this is
2384                            actually within this share and adjust newname accordingly. */
2385                         DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2386                                 "not sharepath %s) "
2387                                 "fnum %d from %s -> %s\n",
2388                                 fsp->conn->connectpath,
2389                                 sharepath,
2390                                 fsp->fnum,
2391                                 fsp->fsp_name,
2392                                 newname ));
2393                 }
2394         }
2395 }
2396
2397 struct case_semantics_state {
2398         connection_struct *conn;
2399         bool case_sensitive;
2400         bool case_preserve;
2401         bool short_case_preserve;
2402 };
2403
2404 /****************************************************************************
2405  Restore case semantics.
2406 ****************************************************************************/
2407 static int restore_case_semantics(struct case_semantics_state *state)
2408 {
2409         state->conn->case_sensitive = state->case_sensitive;
2410         state->conn->case_preserve = state->case_preserve;
2411         state->conn->short_case_preserve = state->short_case_preserve;
2412         return 0;
2413 }
2414
2415 /****************************************************************************
2416  Save case semantics.
2417 ****************************************************************************/
2418 static struct case_semantics_state *set_posix_case_semantics(TALLOC_CTX *mem_ctx,
2419                                                              connection_struct *conn)
2420 {
2421         struct case_semantics_state *result;
2422
2423         if (!(result = talloc(mem_ctx, struct case_semantics_state))) {
2424                 DEBUG(0, ("talloc failed\n"));
2425                 return NULL;
2426         }
2427
2428         result->conn = conn;
2429         result->case_sensitive = conn->case_sensitive;
2430         result->case_preserve = conn->case_preserve;
2431         result->short_case_preserve = conn->short_case_preserve;
2432
2433         /* Set to POSIX. */
2434         conn->case_sensitive = True;
2435         conn->case_preserve = True;
2436         conn->short_case_preserve = True;
2437
2438         talloc_set_destructor(result, restore_case_semantics);
2439
2440         return result;
2441 }
2442
2443 /*
2444  * Wrapper around open_file_ntcreate and open_directory
2445  */
2446
2447 NTSTATUS create_file_unixpath(connection_struct *conn,
2448                               struct smb_request *req,
2449                               const char *fname,
2450                               uint32_t access_mask,
2451                               uint32_t share_access,
2452                               uint32_t create_disposition,
2453                               uint32_t create_options,
2454                               uint32_t file_attributes,
2455                               uint32_t oplock_request,
2456                               SMB_BIG_UINT allocation_size,
2457                               struct security_descriptor *sd,
2458                               struct ea_list *ea_list,
2459
2460                               files_struct **result,
2461                               int *pinfo,
2462                               SMB_STRUCT_STAT *psbuf)
2463 {
2464         SMB_STRUCT_STAT sbuf;
2465         int info = FILE_WAS_OPENED;
2466         files_struct *fsp = NULL;
2467         NTSTATUS status;
2468
2469         DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
2470                   "file_attributes = 0x%x, share_access = 0x%x, "
2471                   "create_disposition = 0x%x create_options = 0x%x "
2472                   "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
2473                   "fname = %s\n",
2474                   (unsigned int)access_mask,
2475                   (unsigned int)file_attributes,
2476                   (unsigned int)share_access,
2477                   (unsigned int)create_disposition,
2478                   (unsigned int)create_options,
2479                   (unsigned int)oplock_request,
2480                   ea_list, sd, fname));
2481
2482         if (create_options & FILE_OPEN_BY_FILE_ID) {
2483                 status = NT_STATUS_NOT_SUPPORTED;
2484                 goto fail;
2485         }
2486
2487         if (req == NULL) {
2488                 oplock_request |= INTERNAL_OPEN_ONLY;
2489         }
2490
2491         if (psbuf != NULL) {
2492                 sbuf = *psbuf;
2493         }
2494         else {
2495                 SET_STAT_INVALID(sbuf);
2496         }
2497
2498         /* This is the correct thing to do (check every time) but can_delete
2499          * is expensive (it may have to read the parent directory
2500          * permissions). So for now we're not doing it unless we have a strong
2501          * hint the client is really going to delete this file. If the client
2502          * is forcing FILE_CREATE let the filesystem take care of the
2503          * permissions. */
2504
2505         /* Setting FILE_SHARE_DELETE is the hint. */
2506
2507         if (lp_acl_check_permissions(SNUM(conn))
2508             && (create_disposition != FILE_CREATE)
2509             && (share_access & FILE_SHARE_DELETE)
2510             && (access_mask & DELETE_ACCESS)
2511             && (((dos_mode(conn, fname, &sbuf) & FILE_ATTRIBUTE_READONLY)
2512                  && !lp_delete_readonly(SNUM(conn)))
2513                 || !can_delete_file_in_directory(conn, fname))) {
2514                 status = NT_STATUS_ACCESS_DENIED;
2515                 goto fail;
2516         }
2517
2518 #if 0
2519         /* We need to support SeSecurityPrivilege for this. */
2520         if ((access_mask & SEC_RIGHT_SYSTEM_SECURITY) &&
2521             !user_has_privileges(current_user.nt_user_token,
2522                                  &se_security)) {
2523                 status = NT_STATUS_PRIVILEGE_NOT_HELD;
2524                 goto fail;
2525         }
2526 #endif
2527
2528         /*
2529          * If it's a request for a directory open, deal with it separately.
2530          */
2531
2532         if (create_options & FILE_DIRECTORY_FILE) {
2533
2534                 /* Can't open a temp directory. IFS kit test. */
2535                 if (file_attributes & FILE_ATTRIBUTE_TEMPORARY) {
2536                         status = NT_STATUS_INVALID_PARAMETER;
2537                         goto fail;
2538                 }
2539
2540                 /*
2541                  * We will get a create directory here if the Win32
2542                  * app specified a security descriptor in the
2543                  * CreateDirectory() call.
2544                  */
2545
2546                 oplock_request = 0;
2547                 status = open_directory(
2548                         conn, req, fname, &sbuf, access_mask, share_access,
2549                         create_disposition, create_options, file_attributes,
2550                         &info, &fsp);
2551         } else {
2552
2553                 /*
2554                  * Ordinary file case.
2555                  */
2556
2557                 status = open_file_ntcreate(
2558                         conn, req, fname, &sbuf, access_mask, share_access,
2559                         create_disposition, create_options, file_attributes,
2560                         oplock_request, &info, &fsp);
2561
2562                 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
2563
2564                         /*
2565                          * Fail the open if it was explicitly a non-directory
2566                          * file.
2567                          */
2568
2569                         if (create_options & FILE_NON_DIRECTORY_FILE) {
2570                                 status = NT_STATUS_FILE_IS_A_DIRECTORY;
2571                                 goto fail;
2572                         }
2573
2574                         oplock_request = 0;
2575                         status = open_directory(
2576                                 conn, req, fname, &sbuf, access_mask,
2577                                 share_access, create_disposition,
2578                                 create_options, file_attributes,
2579                                 &info, &fsp);
2580                 }
2581         }
2582
2583         if (!NT_STATUS_IS_OK(status)) {
2584                 goto fail;
2585         }
2586
2587         /*
2588          * According to the MS documentation, the only time the security
2589          * descriptor is applied to the opened file is iff we *created* the
2590          * file; an existing file stays the same.
2591          *
2592          * Also, it seems (from observation) that you can open the file with
2593          * any access mask but you can still write the sd. We need to override
2594          * the granted access before we call set_sd
2595          * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
2596          */
2597
2598         if ((sd != NULL) && (info == FILE_WAS_CREATED)
2599             && lp_nt_acl_support(SNUM(conn))) {
2600
2601                 uint32_t sec_info_sent = ALL_SECURITY_INFORMATION;
2602                 uint32_t saved_access_mask = fsp->access_mask;
2603
2604                 if (sd->owner_sid==0) {
2605                         sec_info_sent &= ~OWNER_SECURITY_INFORMATION;
2606                 }
2607                 if (sd->group_sid==0) {
2608                         sec_info_sent &= ~GROUP_SECURITY_INFORMATION;
2609                 }
2610                 if (sd->sacl==0) {
2611                         sec_info_sent &= ~SACL_SECURITY_INFORMATION;
2612                 }
2613                 if (sd->dacl==0) {
2614                         sec_info_sent &= ~DACL_SECURITY_INFORMATION;
2615                 }
2616
2617                 fsp->access_mask = FILE_GENERIC_ALL;
2618
2619                 status = SMB_VFS_FSET_NT_ACL(
2620                         fsp, fsp->fh->fd, sec_info_sent, sd);
2621
2622                 fsp->access_mask = saved_access_mask;
2623
2624                 if (!NT_STATUS_IS_OK(status)) {
2625                         goto fail;
2626                 }
2627         }
2628
2629         if ((ea_list != NULL) && (info == FILE_WAS_CREATED)) {
2630                 status = set_ea(conn, fsp, fname, ea_list);
2631                 if (!NT_STATUS_IS_OK(status)) {
2632                         goto fail;
2633                 }
2634         }
2635
2636         if (!fsp->is_directory && S_ISDIR(sbuf.st_mode)) {
2637                 status = NT_STATUS_ACCESS_DENIED;
2638                 goto fail;
2639         }
2640
2641         /* Save the requested allocation size. */
2642         if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
2643                 if (allocation_size
2644                     && (allocation_size > sbuf.st_size)) {
2645                         fsp->initial_allocation_size = smb_roundup(
2646                                 fsp->conn, allocation_size);
2647                         if (fsp->is_directory) {
2648                                 /* Can't set allocation size on a directory. */
2649                                 status = NT_STATUS_ACCESS_DENIED;
2650                                 goto fail;
2651                         }
2652                         if (vfs_allocate_file_space(
2653                                     fsp, fsp->initial_allocation_size) == -1) {
2654                                 status = NT_STATUS_DISK_FULL;
2655                                 goto fail;
2656                         }
2657                 } else {
2658                         fsp->initial_allocation_size = smb_roundup(
2659                                 fsp->conn, (SMB_BIG_UINT)sbuf.st_size);
2660                 }
2661         }
2662
2663         DEBUG(10, ("create_file: info=%d\n", info));
2664
2665         *result = fsp;
2666         if (pinfo != NULL) {
2667                 *pinfo = info;
2668         }
2669         if (psbuf != NULL) {
2670                 *psbuf = sbuf;
2671         }
2672         return NT_STATUS_OK;
2673
2674  fail:
2675         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
2676
2677         if (fsp != NULL) {
2678                 close_file(fsp, ERROR_CLOSE);
2679                 fsp = NULL;
2680         }
2681         return status;
2682 }
2683
2684 NTSTATUS create_file(connection_struct *conn,
2685                      struct smb_request *req,
2686                      uint16_t root_dir_fid,
2687                      const char *fname,
2688                      uint32_t access_mask,
2689                      uint32_t share_access,
2690                      uint32_t create_disposition,
2691                      uint32_t create_options,
2692                      uint32_t file_attributes,
2693                      uint32_t oplock_request,
2694                      SMB_BIG_UINT allocation_size,
2695                      struct security_descriptor *sd,
2696                      struct ea_list *ea_list,
2697
2698                      files_struct **result,
2699                      int *pinfo,
2700                      SMB_STRUCT_STAT *psbuf)
2701 {
2702         TALLOC_CTX *frame = talloc_stackframe();
2703         struct case_semantics_state *case_state = NULL;
2704         SMB_STRUCT_STAT sbuf;
2705         int info = FILE_WAS_OPENED;
2706         files_struct *fsp = NULL;
2707         NTSTATUS status;
2708
2709         DEBUG(10,("create_file: access_mask = 0x%x "
2710                   "file_attributes = 0x%x, share_access = 0x%x, "
2711                   "create_disposition = 0x%x create_options = 0x%x "
2712                   "oplock_request = 0x%x "
2713                   "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
2714                   "fname = %s\n",
2715                   (unsigned int)access_mask,
2716                   (unsigned int)file_attributes,
2717                   (unsigned int)share_access,
2718                   (unsigned int)create_disposition,
2719                   (unsigned int)create_options,
2720                   (unsigned int)oplock_request,
2721                   (unsigned int)root_dir_fid,
2722                   ea_list, sd, fname));
2723
2724         /*
2725          * Get the file name.
2726          */
2727
2728         if (root_dir_fid != 0) {
2729                 /*
2730                  * This filename is relative to a directory fid.
2731                  */
2732                 char *parent_fname = NULL;
2733                 files_struct *dir_fsp = file_fsp(root_dir_fid);
2734
2735                 if (dir_fsp == NULL) {
2736                         status = NT_STATUS_INVALID_HANDLE;
2737                         goto fail;
2738                 }
2739
2740                 if (!dir_fsp->is_directory) {
2741
2742                         /*
2743                          * Check to see if this is a mac fork of some kind.
2744                          */
2745
2746                         if (is_ntfs_stream_name(fname)) {
2747                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
2748                                 goto fail;
2749                         }
2750
2751                         /*
2752                           we need to handle the case when we get a
2753                           relative open relative to a file and the
2754                           pathname is blank - this is a reopen!
2755                           (hint from demyn plantenberg)
2756                         */
2757
2758                         status = NT_STATUS_INVALID_HANDLE;
2759                         goto fail;
2760                 }
2761
2762                 if (ISDOT(dir_fsp->fsp_name)) {
2763                         /*
2764                          * We're at the toplevel dir, the final file name
2765                          * must not contain ./, as this is filtered out
2766                          * normally by srvstr_get_path and unix_convert
2767                          * explicitly rejects paths containing ./.
2768                          */
2769                         parent_fname = talloc_strdup(talloc_tos(), "");
2770                         if (parent_fname == NULL) {
2771                                 status = NT_STATUS_NO_MEMORY;
2772                                 goto fail;
2773                         }
2774                 } else {
2775                         size_t dir_name_len = strlen(dir_fsp->fsp_name);
2776
2777                         /*
2778                          * Copy in the base directory name.
2779                          */
2780
2781                         parent_fname = TALLOC_ARRAY(talloc_tos(), char,
2782                                                     dir_name_len+2);
2783                         if (parent_fname == NULL) {
2784                                 status = NT_STATUS_NO_MEMORY;
2785                                 goto fail;
2786                         }
2787                         memcpy(parent_fname, dir_fsp->fsp_name,
2788                                dir_name_len+1);
2789
2790                         /*
2791                          * Ensure it ends in a '/'.
2792                          * We used TALLOC_SIZE +2 to add space for the '/'.
2793                          */
2794
2795                         if(dir_name_len
2796                            && (parent_fname[dir_name_len-1] != '\\')
2797                            && (parent_fname[dir_name_len-1] != '/')) {
2798                                 parent_fname[dir_name_len] = '/';
2799                                 parent_fname[dir_name_len+1] = '\0';
2800                         }
2801                 }
2802
2803                 fname = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
2804                                         fname);
2805                 if (fname == NULL) {
2806                         status = NT_STATUS_NO_MEMORY;
2807                         goto fail;
2808                 }
2809         } else {
2810                 /*
2811                  * Check to see if this is a mac fork of some kind.
2812                  */
2813
2814                 if (is_ntfs_stream_name(fname)) {
2815                         enum FAKE_FILE_TYPE fake_file_type;
2816
2817                         fake_file_type = is_fake_file(fname);
2818
2819                         if (fake_file_type == FAKE_FILE_TYPE_NONE) {
2820                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
2821                         }
2822
2823                         /*
2824                          * Here we go! support for changing the disk quotas
2825                          * --metze
2826                          *
2827                          * We need to fake up to open this MAGIC QUOTA file
2828                          * and return a valid FID.
2829                          *
2830                          * w2k close this file directly after openening xp
2831                          * also tries a QUERY_FILE_INFO on the file and then
2832                          * close it
2833                          */
2834                         status = open_fake_file(conn, fake_file_type, fname,
2835                                                 access_mask, &fsp);
2836                         if (!NT_STATUS_IS_OK(status)) {
2837                                 goto fail;
2838                         }
2839
2840                         goto done;
2841                 }
2842         }
2843
2844         if ((req != NULL) && (req->flags2 & FLAGS2_DFS_PATHNAMES)) {
2845                 char *resolved_fname;
2846
2847                 status = resolve_dfspath(talloc_tos(), conn, true, fname,
2848                                          &resolved_fname);
2849
2850                 if (!NT_STATUS_IS_OK(status)) {
2851                         /*
2852                          * For PATH_NOT_COVERED we had
2853                          * reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2854                          *                 ERRSRV, ERRbadpath);
2855                          * Need to fix in callers
2856                          */
2857                         goto fail;
2858                 }
2859                 fname = resolved_fname;
2860         }
2861
2862         /*
2863          * Check if POSIX semantics are wanted.
2864          */
2865
2866         if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2867                 case_state = set_posix_case_semantics(talloc_tos(), conn);
2868                 file_attributes &= ~FILE_FLAG_POSIX_SEMANTICS;
2869         }
2870
2871         {
2872                 char *converted_fname;
2873
2874                 SET_STAT_INVALID(sbuf);
2875
2876                 status = unix_convert(talloc_tos(), conn, fname, False,
2877                                       &converted_fname, NULL, &sbuf);
2878                 if (!NT_STATUS_IS_OK(status)) {
2879                         goto fail;
2880                 }
2881                 fname = converted_fname;
2882         }
2883
2884         /* All file access must go through check_name() */
2885
2886         status = check_name(conn, fname);
2887         if (!NT_STATUS_IS_OK(status)) {
2888                 goto fail;
2889         }
2890
2891         status = create_file_unixpath(
2892                 conn, req, fname, access_mask, share_access,
2893                 create_disposition, create_options, file_attributes,
2894                 oplock_request, allocation_size, sd, ea_list,
2895                 &fsp, &info, &sbuf);
2896
2897         if (!NT_STATUS_IS_OK(status)) {
2898                 goto fail;
2899         }
2900
2901  done:
2902         DEBUG(10, ("create_file: info=%d\n", info));
2903
2904         *result = fsp;
2905         if (pinfo != NULL) {
2906                 *pinfo = info;
2907         }
2908         if (psbuf != NULL) {
2909                 *psbuf = sbuf;
2910         }
2911         TALLOC_FREE(frame);
2912         return NT_STATUS_OK;
2913
2914  fail:
2915         DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
2916
2917         if (fsp != NULL) {
2918                 close_file(fsp, ERROR_CLOSE);
2919                 fsp = NULL;
2920         }
2921         TALLOC_FREE(frame);
2922         return status;
2923 }