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