Context Navigation

source: trunk/server/source3/smbd/open.c@ 665

Visit:

Last change on this file since 665 was 620, checked in by Herwig Bauernfeind, 14 years ago
Samba 3.5: Update trunk to 3.5.11
File size: 98.1 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: