s3:vfs_default: add basic support for durable handle request and reconnect
[kai/samba.git] / source3 / smbd / durable.c
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
103         ndr_err = ndr_push_struct_blob(cookie_blob, mem_ctx, &cookie,
104                         (ndr_push_flags_fn_t)ndr_push_vfs_default_durable_cookie);
105         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
106                 NTSTATUS status = ndr_map_error2ntstatus(ndr_err);
107                 return status;
108         }
109
110         return NT_STATUS_OK;
111 }
112
113 NTSTATUS vfs_default_durable_disconnect(struct files_struct *fsp,
114                                         const DATA_BLOB old_cookie,
115                                         TALLOC_CTX *mem_ctx,
116                                         DATA_BLOB *new_cookie)
117 {
118         struct connection_struct *conn = fsp->conn;
119         NTSTATUS status;
120         enum ndr_err_code ndr_err;
121         struct vfs_default_durable_cookie cookie;
122         DATA_BLOB new_cookie_blob = data_blob_null;
123         struct share_mode_lock *lck;
124         bool ok;
125
126         *new_cookie = data_blob_null;
127
128         ZERO_STRUCT(cookie);
129
130         ndr_err = ndr_pull_struct_blob(&old_cookie, talloc_tos(), &cookie,
131                         (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
132         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
133                 status = ndr_map_error2ntstatus(ndr_err);
134                 return status;
135         }
136
137         if (strcmp(cookie.magic, VFS_DEFAULT_DURABLE_COOKIE_MAGIC) != 0) {
138                 return NT_STATUS_INVALID_PARAMETER;
139         }
140
141         if (cookie.version != VFS_DEFAULT_DURABLE_COOKIE_VERSION) {
142                 return NT_STATUS_INVALID_PARAMETER;
143         }
144
145         if (!file_id_equal(&fsp->file_id, &cookie.id)) {
146                 return NT_STATUS_INVALID_PARAMETER;
147         }
148
149         if (!BATCH_OPLOCK_TYPE(fsp->oplock_type)) {
150                 return NT_STATUS_NOT_SUPPORTED;
151         }
152
153         if (fsp->num_pending_break_messages > 0) {
154                 return NT_STATUS_NOT_SUPPORTED;
155         }
156
157         /*
158          * For now let it be simple and do not keep
159          * delete on close files durable open
160          */
161         if (fsp->initial_delete_on_close) {
162                 return NT_STATUS_NOT_SUPPORTED;
163         }
164         if (fsp->delete_on_close) {
165                 return NT_STATUS_NOT_SUPPORTED;
166         }
167
168         if (!VALID_STAT(fsp->fsp_name->st)) {
169                 return NT_STATUS_NOT_SUPPORTED;
170         }
171
172         if (!S_ISREG(fsp->fsp_name->st.st_ex_mode)) {
173                 return NT_STATUS_NOT_SUPPORTED;
174         }
175
176         /*
177          * The above checks are done in mark_share_mode_disconnected() too
178          * but we want to avoid getting the lock if possible
179          */
180         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
181         if (lck != NULL) {
182                 ok = mark_share_mode_disconnected(lck, fsp);
183                 if (!ok) {
184                         TALLOC_FREE(lck);
185                 }
186         }
187         if (lck != NULL) {
188                 ok = brl_mark_disconnected(fsp);
189                 if (!ok) {
190                         TALLOC_FREE(lck);
191                 }
192         }
193         if (lck == NULL) {
194                 return NT_STATUS_NOT_SUPPORTED;
195         }
196         TALLOC_FREE(lck);
197
198         ZERO_STRUCT(cookie);
199         cookie.allow_reconnect = true;
200         cookie.id = fsp->file_id;
201         cookie.servicepath = conn->connectpath;
202         cookie.base_name = fsp->fsp_name->base_name;
203         cookie.initial_allocation_size = fsp->initial_allocation_size;
204         cookie.position_information = fsp->fh->position_information;
205
206         ndr_err = ndr_push_struct_blob(&new_cookie_blob, mem_ctx, &cookie,
207                         (ndr_push_flags_fn_t)ndr_push_vfs_default_durable_cookie);
208         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
209                 status = ndr_map_error2ntstatus(ndr_err);
210                 return status;
211         }
212
213         status = fd_close(fsp);
214         if (!NT_STATUS_IS_OK(status)) {
215                 data_blob_free(&new_cookie_blob);
216                 return status;
217         }
218
219         *new_cookie = new_cookie_blob;
220         return NT_STATUS_OK;
221 }
222
223 NTSTATUS vfs_default_durable_reconnect(struct connection_struct *conn,
224                                        struct smb_request *smb1req,
225                                        struct smbXsrv_open *op,
226                                        const DATA_BLOB old_cookie,
227                                        TALLOC_CTX *mem_ctx,
228                                        files_struct **result,
229                                        DATA_BLOB *new_cookie)
230 {
231         struct share_mode_lock *lck;
232         struct share_mode_entry *e;
233         struct files_struct *fsp = NULL;
234         NTSTATUS status;
235         bool ok;
236         int ret;
237         int flags;
238         struct file_id file_id;
239         struct smb_filename *smb_fname = NULL;
240         enum ndr_err_code ndr_err;
241         struct vfs_default_durable_cookie cookie;
242         DATA_BLOB new_cookie_blob = data_blob_null;
243
244         *result = NULL;
245         *new_cookie = data_blob_null;
246
247         if (!lp_durable_handles(SNUM(conn))) {
248                 return NT_STATUS_NOT_SUPPORTED;
249         }
250
251         /*
252          * the checks for kernel oplocks
253          * and similar things are done
254          * in the vfs_default_durable_cookie()
255          * call below.
256          */
257
258         ZERO_STRUCT(cookie);
259
260         ndr_err = ndr_pull_struct_blob(&old_cookie, talloc_tos(), &cookie,
261                         (ndr_pull_flags_fn_t)ndr_pull_vfs_default_durable_cookie);
262         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
263                 status = ndr_map_error2ntstatus(ndr_err);
264                 return status;
265         }
266
267         if (strcmp(cookie.magic, VFS_DEFAULT_DURABLE_COOKIE_MAGIC) != 0) {
268                 return NT_STATUS_INVALID_PARAMETER;
269         }
270
271         if (cookie.version != VFS_DEFAULT_DURABLE_COOKIE_VERSION) {
272                 return NT_STATUS_INVALID_PARAMETER;
273         }
274
275         if (!cookie.allow_reconnect) {
276                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
277         }
278
279         if (strcmp(cookie.servicepath, conn->connectpath) != 0) {
280                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
281         }
282
283         /* Create an smb_filename with stream_name == NULL. */
284         status = create_synthetic_smb_fname(talloc_tos(),
285                                             cookie.base_name,
286                                             NULL, NULL,
287                                             &smb_fname);
288         if (!NT_STATUS_IS_OK(status)) {
289                 return status;
290         }
291
292         ret = SMB_VFS_LSTAT(conn, smb_fname);
293         if (ret == -1) {
294                 status = map_nt_error_from_unix_common(errno);
295                 DEBUG(1, ("Unable to lstat stream: %s => %s\n",
296                           smb_fname_str_dbg(smb_fname),
297                           nt_errstr(status)));
298                 return status;
299         }
300
301         if (!S_ISREG(smb_fname->st.st_ex_mode)) {
302                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
303         }
304
305         file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
306         if (!file_id_equal(&cookie.id, &file_id)) {
307                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
308         }
309
310         /*
311          * 1. check entry in locking.tdb
312          */
313
314         lck = get_existing_share_mode_lock(mem_ctx, file_id);
315         if (lck == NULL) {
316                 DEBUG(5, ("vfs_default_durable_reconnect: share-mode lock "
317                            "not obtained from db\n"));
318                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
319         }
320
321         if (lck->data->num_share_modes == 0) {
322                 DEBUG(1, ("vfs_default_durable_reconnect: Error: no share-mode "
323                           "entry in existing share mode lock\n"));
324                 TALLOC_FREE(lck);
325                 return NT_STATUS_INTERNAL_DB_ERROR;
326         }
327
328         if (lck->data->num_share_modes > 1) {
329                 /*
330                  * It can't be durable if there is more than one handle
331                  * on the file.
332                  */
333                 DEBUG(5, ("vfs_default_durable_reconnect: more than one "
334                           "share-mode entry - can not be durable\n"));
335                 TALLOC_FREE(lck);
336                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
337         }
338
339         e = &lck->data->share_modes[0];
340
341         if (!server_id_is_disconnected(&e->pid)) {
342                 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
343                           "reconnect for handle that was not marked "
344                           "disconnected (e.g. smbd or cluster node died)\n"));
345                 TALLOC_FREE(lck);
346                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
347         }
348
349         if (e->share_file_id != op->global->open_persistent_id) {
350                 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
351                           "share_file_id changed %llu != %llu"
352                           "(e.g. another client had opened the file)\n",
353                           (unsigned long long)e->share_file_id,
354                           (unsigned long long)op->global->open_persistent_id));
355                 TALLOC_FREE(lck);
356                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
357         }
358
359         if ((e->access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) &&
360             !CAN_WRITE(conn))
361         {
362                 DEBUG(5, ("vfs_default_durable_reconnect: denying durable "
363                           "share[%s] is not writeable anymore\n",
364                           lp_servicename(talloc_tos(), SNUM(conn))));
365                 TALLOC_FREE(lck);
366                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
367         }
368
369         /*
370          * TODO:
371          * add scavenger timer functionality
372          *
373          * For now we always allow the reconnect
374          */
375 #if 0
376         expire_time = op->global->disconnect_time;
377         expire_time += NTTIME_MAGIC(op->global->durable_timeout_msec);
378         if (expire < now) {
379                 //TODO reopen and close before telling the client...
380         }
381 #endif
382
383         /*
384          * 2. proceed with opening file
385          */
386
387         status = fsp_new(conn, conn, &fsp);
388         if (!NT_STATUS_IS_OK(status)) {
389                 DEBUG(0, ("vfs_default_durable_reconnect: failed to create "
390                           "new fsp: %s\n", nt_errstr(status)));
391                 TALLOC_FREE(lck);
392                 return status;
393         }
394
395         fsp->fh->private_options = e->private_options;
396         fsp->fh->gen_id = smbXsrv_open_hash(op);
397         fsp->file_id = file_id;
398         fsp->file_pid = smb1req->smbpid;
399         fsp->vuid = smb1req->vuid;
400         fsp->open_time = e->time;
401         fsp->access_mask = e->access_mask;
402         fsp->share_access = e->share_access;
403         fsp->can_read = ((fsp->access_mask & (FILE_READ_DATA)) != 0);
404         fsp->can_write = ((fsp->access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) != 0);
405
406         /*
407          * TODO:
408          * Do we need to store the modified flag in the DB?
409          * How to handle update_write_time and friends
410          * during a disconnected client on a durable handle?
411          */
412         fsp->modified = false;
413         /*
414          * no durables for directories
415          */
416         fsp->is_directory = false;
417         /*
418          * For normal files, can_lock == !is_directory
419          */
420         fsp->can_lock = true;
421         /*
422          * We do not support aio write behind for smb2
423          */
424         fsp->aio_write_behind = false;
425         fsp->oplock_type = e->op_type;
426
427         fsp->initial_allocation_size = cookie.initial_allocation_size;
428         fsp->fh->position_information = cookie.position_information;
429
430         status = fsp_set_smb_fname(fsp, smb_fname);
431         if (!NT_STATUS_IS_OK(status)) {
432                 TALLOC_FREE(lck);
433                 fsp_free(fsp);
434                 DEBUG(0, ("vfs_default_durable_reconnect: "
435                           "fsp_set_smb_fname failed: %s\n",
436                           nt_errstr(status)));
437                 return status;
438         }
439
440         op->compat = fsp;
441         fsp->op = op;
442
443         e->pid = messaging_server_id(conn->sconn->msg_ctx);
444         e->op_mid = smb1req->mid;
445         e->share_file_id = fsp->fh->gen_id;
446
447         ok = brl_reconnect_disconnected(fsp);
448         if (!ok) {
449                 status = NT_STATUS_INTERNAL_ERROR;
450                 DEBUG(1, ("vfs_default_durable_reconnect: "
451                           "failed to reopen brlocks: %s\n",
452                           nt_errstr(status)));
453                 TALLOC_FREE(lck);
454                 op->compat = NULL;
455                 fsp_free(fsp);
456                 return status;
457         }
458
459         /*
460          * TODO: properly calculate open flags
461          */
462         if (fsp->can_write && fsp->can_read) {
463                 flags = O_RDWR;
464         } else if (fsp->can_write) {
465                 flags = O_WRONLY;
466         } else if (fsp->can_read) {
467                 flags = O_RDONLY;
468         }
469
470         status = fd_open(conn, fsp, flags, 0 /* mode */);
471         if (!NT_STATUS_IS_OK(status)) {
472                 TALLOC_FREE(lck);
473                 DEBUG(1, ("vfs_default_durable_reconnect: failed to open "
474                           "file: %s\n", nt_errstr(status)));
475                 op->compat = NULL;
476                 fsp_free(fsp);
477                 return status;
478         }
479
480         ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
481         if (ret == -1) {
482                 status = map_nt_error_from_unix_common(errno);
483                 DEBUG(1, ("Unable to fstat stream: %s => %s\n",
484                           smb_fname_str_dbg(smb_fname),
485                           nt_errstr(status)));
486                 ret = SMB_VFS_CLOSE(fsp);
487                 if (ret == -1) {
488                         DEBUG(0, ("vfs_default_durable_reconnect: "
489                                   "SMB_VFS_CLOSE failed (%s) - leaking file "
490                                   "descriptor\n", strerror(errno)));
491                 }
492                 TALLOC_FREE(lck);
493                 op->compat = NULL;
494                 fsp_free(fsp);
495                 return status;
496
497         }
498
499         if (!S_ISREG(fsp->fsp_name->st.st_ex_mode)) {
500                 ret = SMB_VFS_CLOSE(fsp);
501                 if (ret == -1) {
502                         DEBUG(0, ("vfs_default_durable_reconnect: "
503                                   "SMB_VFS_CLOSE failed (%s) - leaking file "
504                                   "descriptor\n", strerror(errno)));
505                 }
506                 TALLOC_FREE(lck);
507                 op->compat = NULL;
508                 fsp_free(fsp);
509                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
510         }
511
512         file_id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
513         if (!file_id_equal(&cookie.id, &file_id)) {
514                 ret = SMB_VFS_CLOSE(fsp);
515                 if (ret == -1) {
516                         DEBUG(0, ("vfs_default_durable_reconnect: "
517                                   "SMB_VFS_CLOSE failed (%s) - leaking file "
518                                   "descriptor\n", strerror(errno)));
519                 }
520                 TALLOC_FREE(lck);
521                 op->compat = NULL;
522                 fsp_free(fsp);
523                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
524         }
525
526         status = set_file_oplock(fsp, e->op_type);
527         if (!NT_STATUS_IS_OK(status)) {
528                 DEBUG(1, ("vfs_default_durable_reconnect failed to set oplock "
529                           "after opening file: %s\n", nt_errstr(status)));
530                 ret = SMB_VFS_CLOSE(fsp);
531                 if (ret == -1) {
532                         DEBUG(0, ("vfs_default_durable_reconnect: "
533                                   "SMB_VFS_CLOSE failed (%s) - leaking file "
534                                   "descriptor\n", strerror(errno)));
535                 }
536                 TALLOC_FREE(lck);
537                 op->compat = NULL;
538                 fsp_free(fsp);
539                 return status;
540         }
541
542         status = vfs_default_durable_cookie(fsp, mem_ctx, &new_cookie_blob);
543         if (!NT_STATUS_IS_OK(status)) {
544                 TALLOC_FREE(lck);
545                 DEBUG(1, ("vfs_default_durable_reconnect: "
546                           "vfs_default_durable_cookie - %s\n",
547                           nt_errstr(status)));
548                 op->compat = NULL;
549                 fsp_free(fsp);
550                 return status;
551         }
552
553         smb1req->chain_fsp = fsp;
554         smb1req->smb2req->compat_chain_fsp = fsp;
555
556         DEBUG(10, ("vfs_default_durable_reconnect: opened file '%s'\n",
557                    fsp_str_dbg(fsp)));
558
559         /*
560          * release the sharemode lock: this writes the changes
561          */
562         lck->data->modified = true;
563         TALLOC_FREE(lck);
564
565         *result = fsp;
566         *new_cookie = new_cookie_blob;
567
568         return NT_STATUS_OK;
569 }