2 * Unix SMB/CIFS implementation.
3 * Support for OneFS system interfaces.
5 * Copyright (C) Tim Prouty, 2008
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
23 #include <ifs/ifs_syscalls.h>
24 #include <isi_acl/isi_acl_util.h>
27 * Initialize the sm_lock struct before passing it to ifs_createfile.
29 static void smlock_init(connection_struct *conn, struct sm_lock *sml,
30 bool isexe, uint32_t access_mask, uint32_t share_access,
31 uint32_t create_options)
33 sml->sm_type.doc = false;
34 sml->sm_type.isexe = isexe;
35 sml->sm_type.statonly = is_stat_open(access_mask);
36 sml->sm_type.access_mask = access_mask;
37 sml->sm_type.share_access = share_access;
40 * private_options was previously used for DENY_DOS/DENY_FCB checks in
41 * the kernel, but are now properly handled by fcb_or_dos_open. In
42 * these cases, ifs_createfile will return a sharing violation, which
43 * gives fcb_or_dos_open the chance to open a duplicate file handle.
45 sml->sm_type.private_options = 0;
47 /* 1 second delay is handled in onefs_open.c by deferring the open */
48 sml->sm_timeout = timeval_set(0, 0);
51 static void smlock_dump(int debuglevel, const struct sm_lock *sml)
54 DEBUG(debuglevel, ("sml == NULL\n"));
59 ("smlock: doc=%s, isexec=%s, statonly=%s, access_mask=0x%x, "
60 "share_access=0x%x, private_options=0x%x timeout=%d/%d\n",
61 sml->sm_type.doc ? "True" : "False",
62 sml->sm_type.isexe ? "True" : "False",
63 sml->sm_type.statonly ? "True" : "False",
64 sml->sm_type.access_mask,
65 sml->sm_type.share_access,
66 sml->sm_type.private_options,
67 (int)sml->sm_timeout.tv_sec,
68 (int)sml->sm_timeout.tv_usec));
72 * External interface to ifs_createfile
74 int onefs_sys_create_file(connection_struct *conn,
78 uint32_t open_access_mask,
79 uint32_t share_access,
80 uint32_t create_options,
85 struct security_descriptor *sd,
89 struct sm_lock sml, *psml = NULL;
90 enum oplock_type onefs_oplock;
91 enum oplock_type onefs_granted_oplock = OPLOCK_NONE;
92 struct ifs_security_descriptor ifs_sd = {}, *pifs_sd = NULL;
95 uint32_t onefs_dos_attributes;
97 /* Setup security descriptor and get secinfo. */
101 secinfo = (get_sec_info(sd) & IFS_SEC_INFO_KNOWN_MASK);
103 status = onefs_samba_sd_to_sd(secinfo, sd, &ifs_sd, SNUM(conn));
105 if (!NT_STATUS_IS_OK(status)) {
106 DEBUG(1, ("SD initialization failure: %s",
115 /* Stripping off private bits will be done for us. */
116 onefs_oplock = onefs_samba_oplock_to_oplock(oplock_request);
118 if (!lp_oplocks(SNUM(conn))) {
119 SMB_ASSERT(onefs_oplock == OPLOCK_NONE);
122 /* Convert samba dos flags to UF_DOS_* attributes. */
123 onefs_dos_attributes = dos_attributes_to_stat_dos_flags(dos_flags);
125 DEBUG(10,("onefs_sys_create_file: base_fd = %d, "
126 "open_access_mask = 0x%x, flags = 0x%x, mode = 0x%x, "
127 "desired_oplock = %s, id = 0x%x, secinfo = 0x%x, sd = %p, "
128 "dos_attributes = 0x%x, path = %s\n", base_fd,
129 (unsigned int)open_access_mask,
132 onefs_oplock_str(onefs_oplock),
134 (unsigned int)secinfo, sd,
135 (unsigned int)onefs_dos_attributes, path));
137 /* Initialize smlock struct for files/dirs but not internal opens */
138 if (!(oplock_request & INTERNAL_OPEN_ONLY)) {
139 smlock_init(conn, &sml, is_executable(path), access_mask,
140 share_access, create_options);
144 smlock_dump(10, psml);
146 ret_fd = ifs_createfile(base_fd, path,
147 (enum ifs_ace_rights)open_access_mask, flags & ~O_ACCMODE, mode,
148 onefs_oplock, id, psml, secinfo, pifs_sd, onefs_dos_attributes,
149 &onefs_granted_oplock);
151 DEBUG(10,("onefs_sys_create_file(%s): ret_fd = %d, "
152 "onefs_granted_oplock = %s\n",
153 ret_fd < 0 ? strerror(errno) : "success", ret_fd,
154 onefs_oplock_str(onefs_granted_oplock)));
156 if (granted_oplock) {
158 onefs_oplock_to_samba_oplock(onefs_granted_oplock);
162 aclu_free_sd(pifs_sd, false);
168 * Only talloc the spill buffer once (reallocing when necessary).
170 static char *get_spill_buffer(size_t new_count)
172 static int cur_count = 0;
173 static char *spill_buffer = NULL;
175 /* If a sufficiently sized buffer exists, just return. */
176 if (new_count <= cur_count) {
177 SMB_ASSERT(spill_buffer);
181 /* Allocate the first time. */
182 if (cur_count == 0) {
183 SMB_ASSERT(!spill_buffer);
184 spill_buffer = talloc_array(NULL, char, new_count);
186 cur_count = new_count;
191 /* A buffer exists, but it's not big enough, so realloc. */
192 SMB_ASSERT(spill_buffer);
193 spill_buffer = talloc_realloc(NULL, spill_buffer, char, new_count);
195 cur_count = new_count;
201 * recvfile does zero-copy writes given an fd to write to, and a socket with
202 * some data to write. If recvfile read more than it was able to write, it
203 * spills the data into a buffer. After first reading any additional data
204 * from the socket into the buffer, the spill buffer is then written with a
207 ssize_t onefs_sys_recvfile(int fromfd, int tofd, SMB_OFF_T offset,
210 char *spill_buffer = NULL;
211 bool socket_drained = false;
213 off_t total_rbytes = 0;
214 off_t total_wbytes = 0;
218 DEBUG(10,("onefs_recvfile: from = %d, to = %d, offset=%llu, count = "
219 "%lu\n", fromfd, tofd, offset, count));
226 * Setup up a buffer for recvfile to spill data that has been read
227 * from the socket but not written.
229 spill_buffer = get_spill_buffer(count);
230 if (spill_buffer == NULL) {
236 * Keep trying recvfile until:
237 * - There is no data left to read on the socket, or
238 * - bytes read != bytes written, or
239 * - An error is returned that isn't EINTR/EAGAIN
242 /* Keep track of bytes read/written for recvfile */
246 DEBUG(10, ("calling recvfile loop, offset + total_wbytes = "
247 "%llu, count - total_rbytes = %llu\n",
248 offset + total_wbytes, count - total_rbytes));
250 ret = recvfile(tofd, fromfd, offset + total_wbytes,
251 count - total_wbytes, &rbytes, &wbytes, 0,
254 DEBUG(10, ("recvfile ret = %d, errno = %d, rbytes = %llu, "
255 "wbytes = %llu\n", ret, ret >= 0 ? 0 : errno,
258 /* Update our progress so far */
259 total_rbytes += rbytes;
260 total_wbytes += wbytes;
262 } while ((count - total_rbytes) && (rbytes == wbytes) &&
263 (ret == -1 && (errno == EINTR || errno == EAGAIN)));
265 DEBUG(10, ("total_rbytes = %llu, total_wbytes = %llu\n",
266 total_rbytes, total_wbytes));
268 /* Log if recvfile didn't write everything it read. */
269 if (total_rbytes != total_wbytes) {
270 DEBUG(0, ("partial recvfile: total_rbytes=%llu but "
271 "total_wbytes=%llu, diff = %llu\n", total_rbytes,
272 total_wbytes, total_rbytes - total_wbytes));
273 SMB_ASSERT(total_rbytes > total_wbytes);
277 * If there is still data on the socket, read it off.
279 while (total_rbytes < count) {
281 DEBUG(0, ("shallow recvfile, reading %llu\n",
282 count - total_rbytes));
285 * Read the remaining data into the spill buffer. recvfile
286 * may already have some data in the spill buffer, so start
287 * filling the buffer at total_rbytes - total_wbytes.
289 ret = sys_read(fromfd,
290 spill_buffer + (total_rbytes - total_wbytes),
291 count - total_rbytes);
294 DEBUG(0, ("shallow recvfile read failed: %s\n",
296 /* Socket is dead, so treat as if it were drained. */
297 socket_drained = true;
301 /* Data was read so update the rbytes */
305 if (total_rbytes != count) {
306 smb_panic("Unread recvfile data still on the socket!");
310 * Now write any spilled data + the extra data read off the socket.
312 while (total_wbytes < count) {
314 DEBUG(0, ("partial recvfile, writing %llu\n", count - total_wbytes));
316 ret = sys_pwrite(tofd, spill_buffer, count - total_wbytes,
317 offset + total_wbytes);
320 DEBUG(0, ("partial recvfile write failed: %s\n",
325 /* Data was written so update the wbytes */
333 /* Make sure we always try to drain the socket. */
334 if (!socket_drained && count - total_rbytes) {
335 int saved_errno = errno;
337 if (drain_socket(fromfd, count - total_rbytes) !=
338 count - total_rbytes) {
339 /* Socket is dead! */
340 DEBUG(0, ("drain socket failed: %d\n", errno));