2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
6 Copyright (C) Jeremy Allison 2010
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.
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.
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/>.
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "../libcli/smb/smb_common.h"
27 #include "../lib/util/tevent_ntstatus.h"
28 #include "../librpc/gen_ndr/open_files.h"
29 #include "source3/lib/dbwrap/dbwrap_watch.h"
31 #include "librpc/gen_ndr/ndr_quota.h"
34 #define DBGC_CLASS DBGC_SMB2
36 static struct tevent_req
*smbd_smb2_setinfo_send(TALLOC_CTX
*mem_ctx
,
37 struct tevent_context
*ev
,
38 struct smbd_smb2_request
*smb2req
,
39 struct files_struct
*in_fsp
,
41 uint8_t in_file_info_class
,
42 DATA_BLOB in_input_buffer
,
43 uint32_t in_additional_information
);
44 static NTSTATUS
smbd_smb2_setinfo_recv(struct tevent_req
*req
);
46 static void smbd_smb2_request_setinfo_done(struct tevent_req
*subreq
);
47 NTSTATUS
smbd_smb2_request_process_setinfo(struct smbd_smb2_request
*req
)
49 struct smbXsrv_connection
*xconn
= req
->xconn
;
51 const uint8_t *inbody
;
53 uint8_t in_file_info_class
;
54 uint16_t in_input_buffer_offset
;
55 uint32_t in_input_buffer_length
;
56 DATA_BLOB in_input_buffer
;
57 uint32_t in_additional_information
;
58 uint64_t in_file_id_persistent
;
59 uint64_t in_file_id_volatile
;
60 struct files_struct
*in_fsp
;
61 struct tevent_req
*subreq
;
63 status
= smbd_smb2_request_verify_sizes(req
, 0x21);
64 if (!NT_STATUS_IS_OK(status
)) {
65 return smbd_smb2_request_error(req
, status
);
67 inbody
= SMBD_SMB2_IN_BODY_PTR(req
);
69 in_info_type
= CVAL(inbody
, 0x02);
70 in_file_info_class
= CVAL(inbody
, 0x03);
71 in_input_buffer_length
= IVAL(inbody
, 0x04);
72 in_input_buffer_offset
= SVAL(inbody
, 0x08);
73 /* 0x0A 2 bytes reserved */
74 in_additional_information
= IVAL(inbody
, 0x0C);
75 in_file_id_persistent
= BVAL(inbody
, 0x10);
76 in_file_id_volatile
= BVAL(inbody
, 0x18);
78 if (in_input_buffer_offset
== 0 && in_input_buffer_length
== 0) {
80 } else if (in_input_buffer_offset
!=
81 (SMB2_HDR_BODY
+ SMBD_SMB2_IN_BODY_LEN(req
))) {
82 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
85 if (in_input_buffer_length
> SMBD_SMB2_IN_DYN_LEN(req
)) {
86 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
89 in_input_buffer
.data
= SMBD_SMB2_IN_DYN_PTR(req
);
90 in_input_buffer
.length
= in_input_buffer_length
;
92 if (in_input_buffer
.length
> xconn
->smb2
.server
.max_trans
) {
93 DEBUG(2,("smbd_smb2_request_process_setinfo: "
94 "client ignored max trans: %s: 0x%08X: 0x%08X\n",
95 __location__
, (unsigned)in_input_buffer
.length
,
96 (unsigned)xconn
->smb2
.server
.max_trans
));
97 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
100 status
= smbd_smb2_request_verify_creditcharge(req
,
101 in_input_buffer
.length
);
102 if (!NT_STATUS_IS_OK(status
)) {
103 return smbd_smb2_request_error(req
, status
);
106 in_fsp
= file_fsp_smb2(req
, in_file_id_persistent
, in_file_id_volatile
);
107 if (in_fsp
== NULL
) {
108 return smbd_smb2_request_error(req
, NT_STATUS_FILE_CLOSED
);
111 subreq
= smbd_smb2_setinfo_send(req
, req
->sconn
->ev_ctx
,
116 in_additional_information
);
117 if (subreq
== NULL
) {
118 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
120 tevent_req_set_callback(subreq
, smbd_smb2_request_setinfo_done
, req
);
122 return smbd_smb2_request_pending_queue(req
, subreq
, 500);
125 static void smbd_smb2_request_setinfo_done(struct tevent_req
*subreq
)
127 struct smbd_smb2_request
*req
= tevent_req_callback_data(subreq
,
128 struct smbd_smb2_request
);
131 NTSTATUS error
; /* transport error */
133 status
= smbd_smb2_setinfo_recv(subreq
);
135 if (!NT_STATUS_IS_OK(status
)) {
136 error
= smbd_smb2_request_error(req
, status
);
137 if (!NT_STATUS_IS_OK(error
)) {
138 smbd_server_connection_terminate(req
->xconn
,
145 outbody
= smbd_smb2_generate_outbody(req
, 0x02);
146 if (outbody
.data
== NULL
) {
147 error
= smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
148 if (!NT_STATUS_IS_OK(error
)) {
149 smbd_server_connection_terminate(req
->xconn
,
156 SSVAL(outbody
.data
, 0x00, 0x02); /* struct size */
158 error
= smbd_smb2_request_done(req
, outbody
, NULL
);
159 if (!NT_STATUS_IS_OK(error
)) {
160 smbd_server_connection_terminate(req
->xconn
,
166 struct defer_rename_state
{
167 struct tevent_req
*req
;
168 struct smbd_smb2_request
*smb2req
;
169 struct tevent_context
*ev
;
170 struct files_struct
*fsp
;
175 static int defer_rename_state_destructor(struct defer_rename_state
*rename_state
)
177 SAFE_FREE(rename_state
->data
);
181 static void defer_rename_done(struct tevent_req
*subreq
);
183 static struct tevent_req
*delay_rename_for_lease_break(struct tevent_req
*req
,
184 struct smbd_smb2_request
*smb2req
,
185 struct tevent_context
*ev
,
186 struct files_struct
*fsp
,
187 struct share_mode_lock
*lck
,
192 struct tevent_req
*subreq
;
194 struct share_mode_data
*d
= lck
->data
;
195 struct defer_rename_state
*rename_state
;
197 struct timeval timeout
;
199 if (fsp
->oplock_type
!= LEASE_OPLOCK
) {
203 for (i
=0; i
<d
->num_share_modes
; i
++) {
204 struct share_mode_entry
*e
= &d
->share_modes
[i
];
205 uint32_t e_lease_type
;
208 if (e
->op_type
!= LEASE_OPLOCK
) {
212 e_lease_type
= get_lease_type(d
, e
);
214 if (!(e_lease_type
& SMB2_LEASE_HANDLE
)) {
218 if (smb2_lease_equal(fsp_client_guid(fsp
),
219 &fsp
->lease
->lease
.lease_key
,
225 if (share_mode_stale_pid(d
, i
)) {
230 break_to
= (e_lease_type
& ~SMB2_LEASE_HANDLE
);
232 send_break_message(fsp
->conn
->sconn
->msg_ctx
, &fsp
->file_id
,
240 /* Setup a watch on this record. */
241 rename_state
= talloc_zero(req
, struct defer_rename_state
);
242 if (rename_state
== NULL
) {
246 rename_state
->req
= req
;
247 rename_state
->smb2req
= smb2req
;
248 rename_state
->ev
= ev
;
249 rename_state
->fsp
= fsp
;
250 rename_state
->data
= data
;
251 rename_state
->data_size
= data_size
;
253 talloc_set_destructor(rename_state
, defer_rename_state_destructor
);
255 subreq
= dbwrap_watched_watch_send(
259 (struct server_id
){0});
261 if (subreq
== NULL
) {
262 exit_server("Could not watch share mode record for rename\n");
265 tevent_req_set_callback(subreq
, defer_rename_done
, rename_state
);
267 timeout
= timeval_set(OPLOCK_BREAK_TIMEOUT
*2, 0);
268 if (!tevent_req_set_endtime(subreq
,
270 timeval_sum(&smb2req
->request_time
, &timeout
))) {
271 exit_server("Could not set rename timeout\n");
277 static void defer_rename_done(struct tevent_req
*subreq
)
279 struct defer_rename_state
*state
= tevent_req_callback_data(
280 subreq
, struct defer_rename_state
);
282 struct share_mode_lock
*lck
;
286 status
= dbwrap_watched_watch_recv(subreq
, NULL
, NULL
);
288 if (!NT_STATUS_IS_OK(status
)) {
289 DEBUG(5, ("dbwrap_record_watch_recv returned %s\n",
291 tevent_req_nterror(state
->req
, status
);
296 * Make sure we run as the user again
298 ok
= change_to_user(state
->smb2req
->tcon
->compat
,
299 state
->smb2req
->session
->compat
->vuid
);
301 tevent_req_nterror(state
->req
, NT_STATUS_ACCESS_DENIED
);
305 /* Do we still need to wait ? */
306 lck
= get_existing_share_mode_lock(state
->req
, state
->fsp
->file_id
);
308 tevent_req_nterror(state
->req
, NT_STATUS_UNSUCCESSFUL
);
311 subreq
= delay_rename_for_lease_break(state
->req
,
319 /* Yep - keep waiting. */
326 /* Do the rename under the lock. */
327 status
= smbd_do_setfilepathinfo(state
->fsp
->conn
,
328 state
->smb2req
->smb1req
,
330 SMB2_FILE_RENAME_INFORMATION_INTERNAL
,
332 state
->fsp
->fsp_name
,
338 SAFE_FREE(state
->data
);
340 if (!NT_STATUS_IS_OK(status
)) {
341 tevent_req_nterror(state
->req
, status
);
345 tevent_req_done(state
->req
);
348 struct smbd_smb2_setinfo_state
{
349 struct smbd_smb2_request
*smb2req
;
352 static struct tevent_req
*smbd_smb2_setinfo_send(TALLOC_CTX
*mem_ctx
,
353 struct tevent_context
*ev
,
354 struct smbd_smb2_request
*smb2req
,
355 struct files_struct
*fsp
,
356 uint8_t in_info_type
,
357 uint8_t in_file_info_class
,
358 DATA_BLOB in_input_buffer
,
359 uint32_t in_additional_information
)
361 struct tevent_req
*req
= NULL
;
362 struct smbd_smb2_setinfo_state
*state
= NULL
;
363 struct smb_request
*smbreq
= NULL
;
364 connection_struct
*conn
= smb2req
->tcon
->compat
;
365 struct share_mode_lock
*lck
= NULL
;
368 req
= tevent_req_create(mem_ctx
, &state
,
369 struct smbd_smb2_setinfo_state
);
373 state
->smb2req
= smb2req
;
375 DEBUG(10,("smbd_smb2_setinfo_send: %s - %s\n",
376 fsp_str_dbg(fsp
), fsp_fnum_dbg(fsp
)));
378 smbreq
= smbd_smb2_fake_smb_request(smb2req
);
379 if (tevent_req_nomem(smbreq
, req
)) {
380 return tevent_req_post(req
, ev
);
384 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
385 return tevent_req_post(req
, ev
);
388 switch (in_info_type
) {
389 case SMB2_0_INFO_FILE
:
391 uint16_t file_info_level
;
397 file_info_level
= in_file_info_class
+ 1000;
398 if (file_info_level
== SMB_FILE_RENAME_INFORMATION
) {
399 /* SMB2_FILE_RENAME_INFORMATION_INTERNAL == 0xFF00 + in_file_info_class */
400 file_info_level
= SMB2_FILE_RENAME_INFORMATION_INTERNAL
;
403 if (fsp
->fh
->fd
== -1) {
405 * This is actually a SETFILEINFO on a directory
406 * handle (returned from an NT SMB). NT5.0 seems
407 * to do this call. JRA.
409 if (fsp
->fsp_name
->flags
& SMB_FILENAME_POSIX_PATH
) {
410 /* Always do lstat for UNIX calls. */
411 if (SMB_VFS_LSTAT(conn
, fsp
->fsp_name
)) {
412 DEBUG(3,("smbd_smb2_setinfo_send: "
413 "SMB_VFS_LSTAT of %s failed "
414 "(%s)\n", fsp_str_dbg(fsp
),
416 status
= map_nt_error_from_unix(errno
);
417 tevent_req_nterror(req
, status
);
418 return tevent_req_post(req
, ev
);
421 if (SMB_VFS_STAT(conn
, fsp
->fsp_name
) != 0) {
422 DEBUG(3,("smbd_smb2_setinfo_send: "
423 "fileinfo of %s failed (%s)\n",
426 status
= map_nt_error_from_unix(errno
);
427 tevent_req_nterror(req
, status
);
428 return tevent_req_post(req
, ev
);
431 } else if (fsp
->print_file
) {
433 * Doing a DELETE_ON_CLOSE should cancel a print job.
435 if ((file_info_level
== SMB_SET_FILE_DISPOSITION_INFO
)
436 && in_input_buffer
.length
>= 1
437 && CVAL(in_input_buffer
.data
,0)) {
438 fsp
->fh
->private_options
|= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE
;
440 DEBUG(3,("smbd_smb2_setinfo_send: "
441 "Cancelling print job (%s)\n",
444 tevent_req_done(req
);
445 return tevent_req_post(req
, ev
);
447 tevent_req_nterror(req
,
448 NT_STATUS_OBJECT_PATH_INVALID
);
449 return tevent_req_post(req
, ev
);
453 * Original code - this is an open file.
456 if (SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) != 0) {
457 DEBUG(3,("smbd_smb2_setinfo_send: fstat "
458 "of %s failed (%s)\n",
461 status
= map_nt_error_from_unix(errno
);
462 tevent_req_nterror(req
, status
);
463 return tevent_req_post(req
, ev
);
468 data_size
= in_input_buffer
.length
;
470 data
= (char *)SMB_MALLOC_ARRAY(char, data_size
);
471 if (tevent_req_nomem(data
, req
)) {
472 return tevent_req_post(req
, ev
);
474 memcpy(data
, in_input_buffer
.data
, data_size
);
477 if (file_info_level
== SMB2_FILE_RENAME_INFORMATION_INTERNAL
) {
478 struct tevent_req
*subreq
;
480 lck
= get_existing_share_mode_lock(mem_ctx
,
484 tevent_req_nterror(req
,
485 NT_STATUS_UNSUCCESSFUL
);
486 return tevent_req_post(req
, ev
);
489 subreq
= delay_rename_for_lease_break(req
,
497 /* Wait for lease break response. */
499 /* Ensure we can't be closed in flight. */
500 if (!aio_add_req_to_fsp(fsp
, req
)) {
502 tevent_req_nterror(req
, NT_STATUS_NO_MEMORY
);
503 return tevent_req_post(req
, ev
);
511 status
= smbd_do_setfilepathinfo(conn
, smbreq
, state
,
520 if (!NT_STATUS_IS_OK(status
)) {
521 if (NT_STATUS_EQUAL(status
, NT_STATUS_INVALID_LEVEL
)) {
522 status
= NT_STATUS_INVALID_INFO_CLASS
;
524 tevent_req_nterror(req
, status
);
525 return tevent_req_post(req
, ev
);
530 case SMB2_0_INFO_FILESYSTEM
:
532 uint16_t file_info_level
= in_file_info_class
+ 1000;
534 status
= smbd_do_setfsinfo(conn
, smbreq
, state
,
538 if (!NT_STATUS_IS_OK(status
)) {
539 if (NT_STATUS_EQUAL(status
, NT_STATUS_INVALID_LEVEL
)) {
540 status
= NT_STATUS_INVALID_INFO_CLASS
;
542 tevent_req_nterror(req
, status
);
543 return tevent_req_post(req
, ev
);
548 case SMB2_0_INFO_SECURITY
:
550 if (!CAN_WRITE(conn
)) {
551 tevent_req_nterror(req
, NT_STATUS_ACCESS_DENIED
);
552 return tevent_req_post(req
, ev
);
555 status
= set_sd_blob(fsp
,
556 in_input_buffer
.data
,
557 in_input_buffer
.length
,
558 in_additional_information
&
559 SMB_SUPPORTED_SECINFO_FLAGS
);
560 if (!NT_STATUS_IS_OK(status
)) {
561 tevent_req_nterror(req
, status
);
562 return tevent_req_post(req
, ev
);
567 case SMB2_0_INFO_QUOTA
:
569 #ifdef HAVE_SYS_QUOTAS
570 struct file_quota_information info
= {0};
571 SMB_NTQUOTA_STRUCT qt
= {0};
572 enum ndr_err_code err
;
575 if (!fsp
->fake_file_handle
) {
576 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
577 return tevent_req_post(req
, ev
);
579 err
= ndr_pull_struct_blob(
580 &in_input_buffer
, state
, &info
,
581 (ndr_pull_flags_fn_t
)ndr_pull_file_quota_information
);
582 if (!NDR_ERR_CODE_IS_SUCCESS(err
)) {
583 tevent_req_nterror(req
, NT_STATUS_UNSUCCESSFUL
);
584 return tevent_req_post(req
, ev
);
587 qt
.usedspace
= info
.quota_used
;
589 qt
.softlim
= info
.quota_threshold
;
591 qt
.hardlim
= info
.quota_limit
;
594 ret
= vfs_set_ntquota(fsp
, SMB_USER_QUOTA_TYPE
, &qt
.sid
, &qt
);
596 status
= map_nt_error_from_unix(errno
);
597 tevent_req_nterror(req
, status
);
598 return tevent_req_post(req
, ev
);
600 status
= NT_STATUS_OK
;
603 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
604 return tevent_req_post(req
, ev
);
608 tevent_req_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
609 return tevent_req_post(req
, ev
);
612 tevent_req_done(req
);
613 return tevent_req_post(req
, ev
);
616 static NTSTATUS
smbd_smb2_setinfo_recv(struct tevent_req
*req
)
620 if (tevent_req_is_nterror(req
, &status
)) {
621 tevent_req_received(req
);
625 tevent_req_received(req
);