source: vendor/current/source3/smbd/durable.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 25.7 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Durable Handle default VFS implementation
4
5 Copyright (C) Stefan Metzmacher 2012
6 Copyright (C) Michael Adam 2012
7 Copyright (C) Volker Lendecke 2012
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23#include "includes.h"
24#include "system/filesys.h"
25#include "smbd/smbd.h"
26#include "smbd/globals.h"
27#include "libcli/security/security.h"
28#include "messages.h"
29#include "librpc/gen_ndr/ndr_open_files.h"
30#include "serverid.h"
31#include "fake_file.h"
32
33NTSTATUS vfs_default_durable_cookie(struct files_struct *fsp,
34 TALLOC_CTX *mem_ctx,
35 DATA_BLOB *cookie_blob)
36{
37 struct connection_struct *conn = fsp->conn;
38 enum ndr_err_code ndr_err;
39 struct vfs_default_durable_cookie cookie;
40
41 if (!lp_durable_handles(SNUM(conn))) {
42 return NT_STATUS_NOT_SUPPORTED;
43 }
44
45 if (lp_kernel_share_modes(SNUM(conn))) {
46 /*
47 * We do not support durable handles
48 * if kernel share modes (flocks) are used
49 */
50 return NT_STATUS_NOT_SUPPORTED;
51 }
52
53 if (lp_kernel_oplocks(SNUM(conn))) {
54 /*
55 * We do not support durable handles
56 * if kernel oplocks are used
57 */
58 return NT_STATUS_NOT_SUPPORTED;
59 }
60
61 if ((fsp->current_lock_count > 0) &&
62 lp_posix_locking(fsp->conn->params))
63 {
64 /*
65 * We do not support durable handles
66 * if the handle has posix locks.
67 */
68 return NT_STATUS_NOT_SUPPORTED;
69 }
70
71 if (fsp->is_directory) {
72 return NT_STATUS_NOT_SUPPORTED;
73 }
74
75 if (fsp->fh->fd == -1) {
76 return NT_STATUS_NOT_SUPPORTED;
77 }
78
79 if (is_ntfs_stream_smb_fname(fsp->fsp_name)) {
80 /*
81 * We do not support durable handles
82 * on streams for now.
83 */
84 return NT_STATUS_NOT_SUPPORTED;
85 }
86
87 if (is_fake_file(fsp->fsp_name)) {
88 /*
89 * We do not support durable handles
90 * on fake files.
91 */
92 return NT_STATUS_NOT_SUPPORTED;
93 }
94
95 ZERO_STRUCT(cookie);
96 cookie.allow_reconnect = false;
97 cookie.id = fsp->file_id;
98 cookie.servicepath = conn->connectpath;
99 cookie.base_name = fsp->fsp_name->base_name;
100 cookie.initial_allocation_size = fsp->initial_allocation_size;
101 cookie.position_information = fsp->fh->position_information;
102 cookie.update_write_time_triggered = fsp->update_write_time_triggered;
103 cookie.update_write_time_on_close = fsp->update_write_time_on_close;
104 cookie.write_time_forced = fsp->write_time_forced;
105 cookie.close_write_time = fsp->close_write_time;
106
107 cookie.stat_info.st_ex_dev = fsp->fsp_name->st.st_ex_dev;
108 cookie.stat_info.st_ex_ino = fsp->fsp_name->st.st_ex_ino;
109 cookie.stat_info.st_ex_mode = fsp->fsp_name->st.st_ex_mode;
110 cookie.stat_info.st_ex_nlink = fsp->fsp_name->st.st_ex_nlink;
111 cookie.stat_info.st_ex_uid = fsp->fsp_name->st.st_ex_uid;
112 cookie.stat_info.st_ex_gid = fsp->fsp_name->st.st_ex_gid;
113 cookie.stat_info.st_ex_rdev = fsp->fsp_name->st.st_ex_rdev;
114 cookie.stat_info.st_ex_size = fsp->fsp_name->st.st_ex_size;
115 cookie.stat_info.st_ex_atime = fsp->fsp_name->st.st_ex_atime;
116 cookie.stat_info.st_ex_mtime = fsp->fsp_name->st.st_ex_mtime;
117 cookie.stat_info.st_ex_ctime = fsp->fsp_name->st.st_ex_ctime;
118 cookie.stat_info.st_ex_btime = fsp->fsp_name->st.st_ex_btime;
119 cookie.stat_info.st_ex_calculated_birthtime = fsp->fsp_name->st.st_ex_calculated_birthtime;
120 cookie.stat_info.st_ex_blksize = fsp->fsp_name->st.st_ex_blksize;
121 cookie.stat_info.st_ex_blocks = fsp->fsp_name->st.st_ex_blocks;
122 cookie.stat_info.st_ex_flags = fsp->fsp_name->st.st_ex_flags;
123 cookie.stat_info.st_ex_mask = fsp->fsp_name->st.st_ex_mask;
124
125 ndr_err = ndr_push_struct_blob(cookie_blob, mem_ctx, &cookie,
126 (ndr_push_flags_fn_t)ndr_push_vfs_default_durable_cookie);
127 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
128 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
129 return status;
130 }
131
132 return NT_STATUS_OK;
133}
134
135NTSTATUS vfs_default_durable_disconnect(struct files_struct *fsp,
136 const DATA_BLOB old_cookie,
137 TALLOC_CTX *mem_ctx,
138 DATA_BLOB *new_cookie)
139{
140 struct connection_struct *conn = fsp->conn;
141 NTSTATUS status;
142 enum ndr_err_code ndr_err;
143 struct vfs_default_durable_cookie cookie;
144 DATA_BLOB new_cookie_blob = data_blob_null;
145 struct share_mode_lock *lck;
146 bool ok;
147
148 *new_cookie = data_blob_null;
149
150 ZERO_STRUCT(cookie);
151
152 ndr_err = ndr_pull_struct_blob(&old_cookie, talloc_tos(), &cookie,
153 (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
154 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
155 status = ndr_map_error2ntstatus(ndr_err);
156 return status;
157 }
158
159 if (strcmp(cookie.magic, VFS_DEFAULT_DURABLE_COOKIE_MAGIC) != 0) {
160 return NT_STATUS_INVALID_PARAMETER;
161 }
162
163 if (cookie.version != VFS_DEFAULT_DURABLE_COOKIE_VERSION) {
164 return NT_STATUS_INVALID_PARAMETER;
165 }
166
167 if (!file_id_equal(&fsp->file_id, &cookie.id)) {
168 return NT_STATUS_INVALID_PARAMETER;
169 }
170
171 if ((fsp_lease_type(fsp) & SMB2_LEASE_HANDLE) == 0) {
172 return NT_STATUS_NOT_SUPPORTED;
173 }
174
175 /*
176 * For now let it be simple and do not keep
177 * delete on close files durable open
178 */
179 if (fsp->initial_delete_on_close) {
180 return NT_STATUS_NOT_SUPPORTED;
181 }
182 if (fsp->delete_on_close) {
183 return NT_STATUS_NOT_SUPPORTED;
184 }
185
186 if (!VALID_STAT(fsp->fsp_name->st)) {
187 return NT_STATUS_NOT_SUPPORTED;
188 }
189
190 if (!S_ISREG(fsp->fsp_name->st.st_ex_mode)) {
191 return NT_STATUS_NOT_SUPPORTED;
192 }
193
194 /* Ensure any pending write time updates are done. */
195 if (fsp->update_write_time_event) {
196 update_write_time_handler(fsp->conn->sconn->ev_ctx,
197 fsp->update_write_time_event,
198 timeval_current(),
199 (void *)fsp);
200 }
201
202 /*
203 * The above checks are done in mark_share_mode_disconnected() too
204 * but we want to avoid getting the lock if possible
205 */
206 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
207 if (lck != NULL) {
208 struct smb_file_time ft;
209
210 ZERO_STRUCT(ft);
211
212 if (fsp->write_time_forced) {
213 ft.mtime = lck->data->changed_write_time;
214 } else if (fsp->update_write_time_on_close) {
215 if (null_timespec(fsp->close_write_time)) {
216 ft.mtime = timespec_current();
217 } else {
218 ft.mtime = fsp->close_write_time;
219 }
220 }
221
222 if (!null_timespec(ft.mtime)) {
223 round_timespec(conn->ts_res, &ft.mtime);
224 file_ntimes(conn, fsp->fsp_name, &ft);
225 }
226
227 ok = mark_share_mode_disconnected(lck, fsp);
228 if (!ok) {
229 TALLOC_FREE(lck);
230 }
231 }
232 if (lck != NULL) {
233 ok = brl_mark_disconnected(fsp);
234 if (!ok) {
235 TALLOC_FREE(lck);
236 }
237 }
238 if (lck == NULL) {
239 return NT_STATUS_NOT_SUPPORTED;
240 }
241 TALLOC_FREE(lck);
242
243 status = vfs_stat_fsp(fsp);
244 if (!NT_STATUS_IS_OK(status)) {
245 return status;
246 }
247
248 ZERO_STRUCT(cookie);
249 cookie.allow_reconnect = true;
250 cookie.id = fsp->file_id;
251 cookie.servicepath = conn->connectpath;
252 cookie.base_name = fsp->fsp_name->base_name;
253 cookie.initial_allocation_size = fsp->initial_allocation_size;
254 cookie.position_information = fsp->fh->position_information;
255 cookie.update_write_time_triggered = fsp->update_write_time_triggered;
256 cookie.update_write_time_on_close = fsp->update_write_time_on_close;
257 cookie.write_time_forced = fsp->write_time_forced;
258 cookie.close_write_time = fsp->close_write_time;
259
260 cookie.stat_info.st_ex_dev = fsp->fsp_name->st.st_ex_dev;
261 cookie.stat_info.st_ex_ino = fsp->fsp_name->st.st_ex_ino;
262 cookie.stat_info.st_ex_mode = fsp->fsp_name->st.st_ex_mode;
263 cookie.stat_info.st_ex_nlink = fsp->fsp_name->st.st_ex_nlink;
264 cookie.stat_info.st_ex_uid = fsp->fsp_name->st.st_ex_uid;
265 cookie.stat_info.st_ex_gid = fsp->fsp_name->st.st_ex_gid;
266 cookie.stat_info.st_ex_rdev = fsp->fsp_name->st.st_ex_rdev;
267 cookie.stat_info.st_ex_size = fsp->fsp_name->st.st_ex_size;
268 cookie.stat_info.st_ex_atime = fsp->fsp_name->st.st_ex_atime;
269 cookie.stat_info.st_ex_mtime = fsp->fsp_name->st.st_ex_mtime;
270 cookie.stat_info.st_ex_ctime = fsp->fsp_name->st.st_ex_ctime;
271 cookie.stat_info.st_ex_btime = fsp->fsp_name->st.st_ex_btime;
272 cookie.stat_info.st_ex_calculated_birthtime = fsp->fsp_name->st.st_ex_calculated_birthtime;
273 cookie.stat_info.st_ex_blksize = fsp->fsp_name->st.st_ex_blksize;
274 cookie.stat_info.st_ex_blocks = fsp->fsp_name->st.st_ex_blocks;
275 cookie.stat_info.st_ex_flags = fsp->fsp_name->st.st_ex_flags;
276 cookie.stat_info.st_ex_mask = fsp->fsp_name->st.st_ex_mask;
277
278 ndr_err = ndr_push_struct_blob(&new_cookie_blob, mem_ctx, &cookie,
279 (ndr_push_flags_fn_t)ndr_push_vfs_default_durable_cookie);
280 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
281 status = ndr_map_error2ntstatus(ndr_err);
282 return status;
283 }
284
285 status = fd_close(fsp);
286 if (!NT_STATUS_IS_OK(status)) {
287 data_blob_free(&new_cookie_blob);
288 return status;
289 }
290
291 *new_cookie = new_cookie_blob;
292 return NT_STATUS_OK;
293}
294
295
296/**
297 * Check whether a cookie-stored struct info is the same
298 * as a given SMB_STRUCT_STAT, as coming with the fsp.
299 */
300static bool vfs_default_durable_reconnect_check_stat(
301 struct vfs_default_durable_stat *cookie_st,
302 SMB_STRUCT_STAT *fsp_st,
303 const char *name)
304{
305 int ret;
306
307 if (cookie_st->st_ex_dev != fsp_st->st_ex_dev) {
308 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
309 "stat_ex.%s differs: "
310 "cookie:%llu != stat:%llu, "
311 "denying durable reconnect\n",
312 name,
313 "st_ex_dev",
314 (unsigned long long)cookie_st->st_ex_dev,
315 (unsigned long long)fsp_st->st_ex_dev));
316 return false;
317 }
318
319 if (cookie_st->st_ex_ino != fsp_st->st_ex_ino) {
320 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
321 "stat_ex.%s differs: "
322 "cookie:%llu != stat:%llu, "
323 "denying durable reconnect\n",
324 name,
325 "st_ex_ino",
326 (unsigned long long)cookie_st->st_ex_ino,
327 (unsigned long long)fsp_st->st_ex_ino));
328 return false;
329 }
330
331 if (cookie_st->st_ex_mode != fsp_st->st_ex_mode) {
332 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
333 "stat_ex.%s differs: "
334 "cookie:%llu != stat:%llu, "
335 "denying durable reconnect\n",
336 name,
337 "st_ex_mode",
338 (unsigned long long)cookie_st->st_ex_mode,
339 (unsigned long long)fsp_st->st_ex_mode));
340 return false;
341 }
342
343 if (cookie_st->st_ex_nlink != fsp_st->st_ex_nlink) {
344 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
345 "stat_ex.%s differs: "
346 "cookie:%llu != stat:%llu, "
347 "denying durable reconnect\n",
348 name,
349 "st_ex_nlink",
350 (unsigned long long)cookie_st->st_ex_nlink,
351 (unsigned long long)fsp_st->st_ex_nlink));
352 return false;
353 }
354
355 if (cookie_st->st_ex_uid != fsp_st->st_ex_uid) {
356 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
357 "stat_ex.%s differs: "
358 "cookie:%llu != stat:%llu, "
359 "denying durable reconnect\n",
360 name,
361 "st_ex_uid",
362 (unsigned long long)cookie_st->st_ex_uid,
363 (unsigned long long)fsp_st->st_ex_uid));
364 return false;
365 }
366
367 if (cookie_st->st_ex_gid != fsp_st->st_ex_gid) {
368 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
369 "stat_ex.%s differs: "
370 "cookie:%llu != stat:%llu, "
371 "denying durable reconnect\n",
372 name,
373 "st_ex_gid",
374 (unsigned long long)cookie_st->st_ex_gid,
375 (unsigned long long)fsp_st->st_ex_gid));
376 return false;
377 }
378
379 if (cookie_st->st_ex_rdev != fsp_st->st_ex_rdev) {
380 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
381 "stat_ex.%s differs: "
382 "cookie:%llu != stat:%llu, "
383 "denying durable reconnect\n",
384 name,
385 "st_ex_rdev",
386 (unsigned long long)cookie_st->st_ex_rdev,
387 (unsigned long long)fsp_st->st_ex_rdev));
388 return false;
389 }
390
391 if (cookie_st->st_ex_size != fsp_st->st_ex_size) {
392 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
393 "stat_ex.%s differs: "
394 "cookie:%llu != stat:%llu, "
395 "denying durable reconnect\n",
396 name,
397 "st_ex_size",
398 (unsigned long long)cookie_st->st_ex_size,
399 (unsigned long long)fsp_st->st_ex_size));
400 return false;
401 }
402
403 ret = timespec_compare(&cookie_st->st_ex_atime,
404 &fsp_st->st_ex_atime);
405 if (ret != 0) {
406 struct timeval tc, ts;
407 tc = convert_timespec_to_timeval(cookie_st->st_ex_atime);
408 ts = convert_timespec_to_timeval(fsp_st->st_ex_atime);
409
410 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
411 "stat_ex.%s differs: "
412 "cookie:'%s' != stat:'%s', "
413 "denying durable reconnect\n",
414 name,
415 "st_ex_atime",
416 timeval_string(talloc_tos(), &tc, true),
417 timeval_string(talloc_tos(), &ts, true)));
418 return false;
419 }
420
421 ret = timespec_compare(&cookie_st->st_ex_mtime,
422 &fsp_st->st_ex_mtime);
423 if (ret != 0) {
424 struct timeval tc, ts;
425 tc = convert_timespec_to_timeval(cookie_st->st_ex_mtime);
426 ts = convert_timespec_to_timeval(fsp_st->st_ex_mtime);
427
428 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
429 "stat_ex.%s differs: "
430 "cookie:'%s' != stat:'%s', "
431 "denying durable reconnect\n",
432 name,
433 "st_ex_mtime",
434 timeval_string(talloc_tos(), &tc, true),
435 timeval_string(talloc_tos(), &ts, true)));
436 return false;
437 }
438
439 ret = timespec_compare(&cookie_st->st_ex_ctime,
440 &fsp_st->st_ex_ctime);
441 if (ret != 0) {
442 struct timeval tc, ts;
443 tc = convert_timespec_to_timeval(cookie_st->st_ex_ctime);
444 ts = convert_timespec_to_timeval(fsp_st->st_ex_ctime);
445
446 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
447 "stat_ex.%s differs: "
448 "cookie:'%s' != stat:'%s', "
449 "denying durable reconnect\n",
450 name,
451 "st_ex_ctime",
452 timeval_string(talloc_tos(), &tc, true),
453 timeval_string(talloc_tos(), &ts, true)));
454 return false;
455 }
456
457 ret = timespec_compare(&cookie_st->st_ex_btime,
458 &fsp_st->st_ex_btime);
459 if (ret != 0) {
460 struct timeval tc, ts;
461 tc = convert_timespec_to_timeval(cookie_st->st_ex_btime);
462 ts = convert_timespec_to_timeval(fsp_st->st_ex_btime);
463
464 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
465 "stat_ex.%s differs: "
466 "cookie:'%s' != stat:'%s', "
467 "denying durable reconnect\n",
468 name,
469 "st_ex_btime",
470 timeval_string(talloc_tos(), &tc, true),
471 timeval_string(talloc_tos(), &ts, true)));
472 return false;
473 }
474
475 if (cookie_st->st_ex_calculated_birthtime !=
476 fsp_st->st_ex_calculated_birthtime)
477 {
478 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
479 "stat_ex.%s differs: "
480 "cookie:%llu != stat:%llu, "
481 "denying durable reconnect\n",
482 name,
483 "st_ex_calculated_birthtime",
484 (unsigned long long)cookie_st->st_ex_calculated_birthtime,
485 (unsigned long long)fsp_st->st_ex_calculated_birthtime));
486 return false;
487 }
488
489 if (cookie_st->st_ex_blksize != fsp_st->st_ex_blksize) {
490 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
491 "stat_ex.%s differs: "
492 "cookie:%llu != stat:%llu, "
493 "denying durable reconnect\n",
494 name,
495 "st_ex_blksize",
496 (unsigned long long)cookie_st->st_ex_blksize,
497 (unsigned long long)fsp_st->st_ex_blksize));
498 return false;
499 }
500
501 if (cookie_st->st_ex_blocks != fsp_st->st_ex_blocks) {
502 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
503 "stat_ex.%s differs: "
504 "cookie:%llu != stat:%llu, "
505 "denying durable reconnect\n",
506 name,
507 "st_ex_blocks",
508 (unsigned long long)cookie_st->st_ex_blocks,
509 (unsigned long long)fsp_st->st_ex_blocks));
510 return false;
511 }
512
513 if (cookie_st->st_ex_flags != fsp_st->st_ex_flags) {
514 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
515 "stat_ex.%s differs: "
516 "cookie:%llu != stat:%llu, "
517 "denying durable reconnect\n",
518 name,
519 "st_ex_flags",
520 (unsigned long long)cookie_st->st_ex_flags,
521 (unsigned long long)fsp_st->st_ex_flags));
522 return false;
523 }
524
525 if (cookie_st->st_ex_mask != fsp_st->st_ex_mask) {
526 DEBUG(1, ("vfs_default_durable_reconnect (%s): "
527 "stat_ex.%s differs: "
528 "cookie:%llu != stat:%llu, "
529 "denying durable reconnect\n",
530 name,
531 "st_ex_mask",
532 (unsigned long long)cookie_st->st_ex_mask,
533 (unsigned long long)fsp_st->st_ex_mask));
534 return false;
535 }
536
537 return true;
538}
539
540NTSTATUS vfs_default_durable_reconnect(struct connection_struct *conn,
541 struct smb_request *smb1req,
542 struct smbXsrv_open *op,
543 const DATA_BLOB old_cookie,
544 TALLOC_CTX *mem_ctx,
545 files_struct **result,
546 DATA_BLOB *new_cookie)
547{
548 struct share_mode_lock *lck;
549 struct share_mode_entry *e;
550 struct files_struct *fsp = NULL;
551 NTSTATUS status;
552 bool ok;
553 int ret;
554 int flags = 0;
555 struct file_id file_id;
556 struct smb_filename *smb_fname = NULL;
557 enum ndr_err_code ndr_err;
558 struct vfs_default_durable_cookie cookie;
559 DATA_BLOB new_cookie_blob = data_blob_null;
560
561 *result = NULL;
562 *new_cookie = data_blob_null;
563
564 if (!lp_durable_handles(SNUM(conn))) {
565 return NT_STATUS_NOT_SUPPORTED;
566 }
567
568 /*
569 * the checks for kernel oplocks
570 * and similar things are done
571 * in the vfs_default_durable_cookie()
572 * call below.
573 */
574
575 ZERO_STRUCT(cookie);
576
577 ndr_err = ndr_pull_struct_blob(&old_cookie, talloc_tos(), &cookie,
578 (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
579 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
580 status = ndr_map_error2ntstatus(ndr_err);
581 return status;
582 }
583
584 if (strcmp(cookie.magic, VFS_DEFAULT_DURABLE_COOKIE_MAGIC) != 0) {
585 return NT_STATUS_INVALID_PARAMETER;
586 }
587
588 if (cookie.version != VFS_DEFAULT_DURABLE_COOKIE_VERSION) {
589 return NT_STATUS_INVALID_PARAMETER;
590 }
591
592 if (!cookie.allow_reconnect) {
593 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
594 }
595
596 if (strcmp(cookie.servicepath, conn->connectpath) != 0) {
597 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
598 }
599
600 /* Create an smb_filename with stream_name == NULL. */
601 smb_fname = synthetic_smb_fname(talloc_tos(), cookie.base_name,
602 NULL, NULL);
603 if (smb_fname == NULL) {
604 return NT_STATUS_NO_MEMORY;
605 }
606
607 ret = SMB_VFS_LSTAT(conn, smb_fname);
608 if (ret == -1) {
609 status = map_nt_error_from_unix_common(errno);
610 DEBUG(1, ("Unable to lstat stream: %s => %s\n",
611 smb_fname_str_dbg(smb_fname),
612 nt_errstr(status)));
613 return status;
614 }
615
616 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
617 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
618 }
619
620 file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
621 if (!file_id_equal(&cookie.id, &file_id)) {
622 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
623 }
624
625 /*
626 * 1. check entry in locking.tdb
627 */
628
629 lck = get_existing_share_mode_lock(mem_ctx, file_id);
630 if (lck == NULL) {
631 DEBUG(5, ("vfs_default_durable_reconnect: share-mode lock "
632 "not obtained from db\n"));
633 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
634 }
635
636 if (lck->data->num_share_modes == 0) {
637 DEBUG(1, ("vfs_default_durable_reconnect: Error: no share-mode "
638 "entry in existing share mode lock\n"));
639 TALLOC_FREE(lck);
640 return NT_STATUS_INTERNAL_DB_ERROR;
641 }
642
643 if (lck->data->num_share_modes > 1) {
644 /*
645 * It can't be durable if there is more than one handle
646 * on the file.
647 */
648 DEBUG(5, ("vfs_default_durable_reconnect: more than one "
649 "share-mode entry - can not be durable\n"));
650 TALLOC_FREE(lck);
651 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
652 }
653
654 e = &lck->data->share_modes[0];
655
656 if (!server_id_is_disconnected(&e->pid)) {
657 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
658 "reconnect for handle that was not marked "
659 "disconnected (e.g. smbd or cluster node died)\n"));
660 TALLOC_FREE(lck);
661 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
662 }
663
664 if (e->share_file_id != op->global->open_persistent_id) {
665 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
666 "share_file_id changed %llu != %llu"
667 "(e.g. another client had opened the file)\n",
668 (unsigned long long)e->share_file_id,
669 (unsigned long long)op->global->open_persistent_id));
670 TALLOC_FREE(lck);
671 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
672 }
673
674 if ((e->access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) &&
675 !CAN_WRITE(conn))
676 {
677 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
678 "share[%s] is not writeable anymore\n",
679 lp_servicename(talloc_tos(), SNUM(conn))));
680 TALLOC_FREE(lck);
681 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
682 }
683
684 /*
685 * 2. proceed with opening file
686 */
687
688 status = fsp_new(conn, conn, &fsp);
689 if (!NT_STATUS_IS_OK(status)) {
690 DEBUG(0, ("vfs_default_durable_reconnect: failed to create "
691 "new fsp: %s\n", nt_errstr(status)));
692 TALLOC_FREE(lck);
693 return status;
694 }
695
696 fsp->fh->private_options = e->private_options;
697 fsp->fh->gen_id = smbXsrv_open_hash(op);
698 fsp->file_id = file_id;
699 fsp->file_pid = smb1req->smbpid;
700 fsp->vuid = smb1req->vuid;
701 fsp->open_time = e->time;
702 fsp->access_mask = e->access_mask;
703 fsp->share_access = e->share_access;
704 fsp->can_read = ((fsp->access_mask & (FILE_READ_DATA)) != 0);
705 fsp->can_write = ((fsp->access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) != 0);
706 fsp->fnum = op->local_id;
707
708 /*
709 * TODO:
710 * Do we need to store the modified flag in the DB?
711 */
712 fsp->modified = false;
713 /*
714 * no durables for directories
715 */
716 fsp->is_directory = false;
717 /*
718 * For normal files, can_lock == !is_directory
719 */
720 fsp->can_lock = true;
721 /*
722 * We do not support aio write behind for smb2
723 */
724 fsp->aio_write_behind = false;
725 fsp->oplock_type = e->op_type;
726
727 if (fsp->oplock_type == LEASE_OPLOCK) {
728 struct share_mode_lease *l = &lck->data->leases[e->lease_idx];
729 struct smb2_lease_key key;
730
731 key.data[0] = l->lease_key.data[0];
732 key.data[1] = l->lease_key.data[1];
733
734 fsp->lease = find_fsp_lease(fsp, &key, l);
735 if (fsp->lease == NULL) {
736 TALLOC_FREE(lck);
737 fsp_free(fsp);
738 return NT_STATUS_NO_MEMORY;
739 }
740
741 /*
742 * Ensure the existing client guid matches the
743 * stored one in the share_mode_lease.
744 */
745 if (!GUID_equal(fsp_client_guid(fsp),
746 &l->client_guid)) {
747 TALLOC_FREE(lck);
748 fsp_free(fsp);
749 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
750 }
751 }
752
753 fsp->initial_allocation_size = cookie.initial_allocation_size;
754 fsp->fh->position_information = cookie.position_information;
755 fsp->update_write_time_triggered = cookie.update_write_time_triggered;
756 fsp->update_write_time_on_close = cookie.update_write_time_on_close;
757 fsp->write_time_forced = cookie.write_time_forced;
758 fsp->close_write_time = cookie.close_write_time;
759
760 status = fsp_set_smb_fname(fsp, smb_fname);
761 if (!NT_STATUS_IS_OK(status)) {
762 TALLOC_FREE(lck);
763 fsp_free(fsp);
764 DEBUG(0, ("vfs_default_durable_reconnect: "
765 "fsp_set_smb_fname failed: %s\n",
766 nt_errstr(status)));
767 return status;
768 }
769
770 op->compat = fsp;
771 fsp->op = op;
772
773 e->pid = messaging_server_id(conn->sconn->msg_ctx);
774 e->op_mid = smb1req->mid;
775 e->share_file_id = fsp->fh->gen_id;
776
777 ok = brl_reconnect_disconnected(fsp);
778 if (!ok) {
779 status = NT_STATUS_INTERNAL_ERROR;
780 DEBUG(1, ("vfs_default_durable_reconnect: "
781 "failed to reopen brlocks: %s\n",
782 nt_errstr(status)));
783 TALLOC_FREE(lck);
784 op->compat = NULL;
785 fsp_free(fsp);
786 return status;
787 }
788
789 /*
790 * TODO: properly calculate open flags
791 */
792 if (fsp->can_write && fsp->can_read) {
793 flags = O_RDWR;
794 } else if (fsp->can_write) {
795 flags = O_WRONLY;
796 } else if (fsp->can_read) {
797 flags = O_RDONLY;
798 }
799
800 status = fd_open(conn, fsp, flags, 0 /* mode */);
801 if (!NT_STATUS_IS_OK(status)) {
802 TALLOC_FREE(lck);
803 DEBUG(1, ("vfs_default_durable_reconnect: failed to open "
804 "file: %s\n", nt_errstr(status)));
805 op->compat = NULL;
806 fsp_free(fsp);
807 return status;
808 }
809
810 /*
811 * We now check the stat info stored in the cookie against
812 * the current stat data from the file we just opened.
813 * If any detail differs, we deny the durable reconnect,
814 * because in that case it is very likely that someone
815 * opened the file while the handle was disconnected,
816 * which has to be interpreted as an oplock break.
817 */
818
819 ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
820 if (ret == -1) {
821 status = map_nt_error_from_unix_common(errno);
822 DEBUG(1, ("Unable to fstat stream: %s => %s\n",
823 smb_fname_str_dbg(smb_fname),
824 nt_errstr(status)));
825 ret = SMB_VFS_CLOSE(fsp);
826 if (ret == -1) {
827 DEBUG(0, ("vfs_default_durable_reconnect: "
828 "SMB_VFS_CLOSE failed (%s) - leaking file "
829 "descriptor\n", strerror(errno)));
830 }
831 TALLOC_FREE(lck);
832 op->compat = NULL;
833 fsp_free(fsp);
834 return status;
835 }
836
837 if (!S_ISREG(fsp->fsp_name->st.st_ex_mode)) {
838 ret = SMB_VFS_CLOSE(fsp);
839 if (ret == -1) {
840 DEBUG(0, ("vfs_default_durable_reconnect: "
841 "SMB_VFS_CLOSE failed (%s) - leaking file "
842 "descriptor\n", strerror(errno)));
843 }
844 TALLOC_FREE(lck);
845 op->compat = NULL;
846 fsp_free(fsp);
847 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
848 }
849
850 file_id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
851 if (!file_id_equal(&cookie.id, &file_id)) {
852 ret = SMB_VFS_CLOSE(fsp);
853 if (ret == -1) {
854 DEBUG(0, ("vfs_default_durable_reconnect: "
855 "SMB_VFS_CLOSE failed (%s) - leaking file "
856 "descriptor\n", strerror(errno)));
857 }
858 TALLOC_FREE(lck);
859 op->compat = NULL;
860 fsp_free(fsp);
861 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
862 }
863
864 ok = vfs_default_durable_reconnect_check_stat(&cookie.stat_info,
865 &fsp->fsp_name->st,
866 fsp_str_dbg(fsp));
867 if (!ok) {
868 ret = SMB_VFS_CLOSE(fsp);
869 if (ret == -1) {
870 DEBUG(0, ("vfs_default_durable_reconnect: "
871 "SMB_VFS_CLOSE failed (%s) - leaking file "
872 "descriptor\n", strerror(errno)));
873 }
874 TALLOC_FREE(lck);
875 op->compat = NULL;
876 fsp_free(fsp);
877 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
878 }
879
880 status = set_file_oplock(fsp);
881 if (!NT_STATUS_IS_OK(status)) {
882 DEBUG(1, ("vfs_default_durable_reconnect failed to set oplock "
883 "after opening file: %s\n", nt_errstr(status)));
884 ret = SMB_VFS_CLOSE(fsp);
885 if (ret == -1) {
886 DEBUG(0, ("vfs_default_durable_reconnect: "
887 "SMB_VFS_CLOSE failed (%s) - leaking file "
888 "descriptor\n", strerror(errno)));
889 }
890 TALLOC_FREE(lck);
891 op->compat = NULL;
892 fsp_free(fsp);
893 return status;
894 }
895
896 status = vfs_default_durable_cookie(fsp, mem_ctx, &new_cookie_blob);
897 if (!NT_STATUS_IS_OK(status)) {
898 TALLOC_FREE(lck);
899 DEBUG(1, ("vfs_default_durable_reconnect: "
900 "vfs_default_durable_cookie - %s\n",
901 nt_errstr(status)));
902 op->compat = NULL;
903 fsp_free(fsp);
904 return status;
905 }
906
907 smb1req->chain_fsp = fsp;
908 smb1req->smb2req->compat_chain_fsp = fsp;
909
910 DEBUG(10, ("vfs_default_durable_reconnect: opened file '%s'\n",
911 fsp_str_dbg(fsp)));
912
913 /*
914 * release the sharemode lock: this writes the changes
915 */
916 lck->data->modified = true;
917 TALLOC_FREE(lck);
918
919 *result = fsp;
920 *new_cookie = new_cookie_blob;
921
922 return NT_STATUS_OK;
923}
Note: See TracBrowser for help on using the repository browser.