2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 #include "smbd/smbd.h"
23 #include "smbd/globals.h"
24 #include "../libcli/smb/smb_common.h"
25 #include "../libcli/security/security.h"
27 #include "lib/param/loadparm.h"
28 #include "../lib/util/tevent_ntstatus.h"
30 static struct tevent_req *smbd_smb2_tree_connect_send(TALLOC_CTX *mem_ctx,
31 struct tevent_context *ev,
32 struct smbd_smb2_request *smb2req,
34 static NTSTATUS smbd_smb2_tree_connect_recv(struct tevent_req *req,
35 uint8_t *out_share_type,
36 uint32_t *out_share_flags,
37 uint32_t *out_capabilities,
38 uint32_t *out_maximal_access,
39 uint32_t *out_tree_id);
41 static void smbd_smb2_request_tcon_done(struct tevent_req *subreq);
43 NTSTATUS smbd_smb2_request_process_tcon(struct smbd_smb2_request *req)
45 const uint8_t *inbody;
46 int i = req->current_idx;
47 uint16_t in_path_offset;
48 uint16_t in_path_length;
49 DATA_BLOB in_path_buffer;
51 size_t in_path_string_size;
54 struct tevent_req *subreq;
56 status = smbd_smb2_request_verify_sizes(req, 0x09);
57 if (!NT_STATUS_IS_OK(status)) {
58 return smbd_smb2_request_error(req, status);
60 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
62 in_path_offset = SVAL(inbody, 0x04);
63 in_path_length = SVAL(inbody, 0x06);
65 if (in_path_offset != (SMB2_HDR_BODY + req->in.vector[i+1].iov_len)) {
66 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
69 if (in_path_length > req->in.vector[i+2].iov_len) {
70 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
73 in_path_buffer.data = (uint8_t *)req->in.vector[i+2].iov_base;
74 in_path_buffer.length = in_path_length;
76 ok = convert_string_talloc(req, CH_UTF16, CH_UNIX,
78 in_path_buffer.length,
80 &in_path_string_size);
82 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
85 if (in_path_buffer.length == 0) {
86 in_path_string_size = 0;
89 if (strlen(in_path_string) != in_path_string_size) {
90 return smbd_smb2_request_error(req, NT_STATUS_BAD_NETWORK_NAME);
93 subreq = smbd_smb2_tree_connect_send(req,
98 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
100 tevent_req_set_callback(subreq, smbd_smb2_request_tcon_done, req);
102 return smbd_smb2_request_pending_queue(req, subreq, 500);
105 static void smbd_smb2_request_tcon_done(struct tevent_req *subreq)
107 struct smbd_smb2_request *req =
108 tevent_req_callback_data(subreq,
109 struct smbd_smb2_request);
110 int i = req->current_idx;
113 uint8_t out_share_type = 0;
114 uint32_t out_share_flags = 0;
115 uint32_t out_capabilities = 0;
116 uint32_t out_maximal_access = 0;
117 uint32_t out_tree_id = 0;
121 status = smbd_smb2_tree_connect_recv(subreq,
128 if (!NT_STATUS_IS_OK(status)) {
129 error = smbd_smb2_request_error(req, status);
130 if (!NT_STATUS_IS_OK(error)) {
131 smbd_server_connection_terminate(req->sconn,
138 outhdr = (uint8_t *)req->out.vector[i].iov_base;
140 outbody = data_blob_talloc(req->out.vector, NULL, 0x10);
141 if (outbody.data == NULL) {
142 error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
143 if (!NT_STATUS_IS_OK(error)) {
144 smbd_server_connection_terminate(req->sconn,
151 SIVAL(outhdr, SMB2_HDR_TID, out_tree_id);
153 SSVAL(outbody.data, 0x00, 0x10); /* struct size */
154 SCVAL(outbody.data, 0x02,
155 out_share_type); /* share type */
156 SCVAL(outbody.data, 0x03, 0); /* reserved */
157 SIVAL(outbody.data, 0x04,
158 out_share_flags); /* share flags */
159 SIVAL(outbody.data, 0x08,
160 out_capabilities); /* capabilities */
161 SIVAL(outbody.data, 0x0C,
162 out_maximal_access); /* maximal access */
164 error = smbd_smb2_request_done(req, outbody, NULL);
165 if (!NT_STATUS_IS_OK(error)) {
166 smbd_server_connection_terminate(req->sconn,
172 static NTSTATUS smbd_smb2_tree_connect(struct smbd_smb2_request *req,
174 uint8_t *out_share_type,
175 uint32_t *out_share_flags,
176 uint32_t *out_capabilities,
177 uint32_t *out_maximal_access,
178 uint32_t *out_tree_id)
180 const char *share = in_path;
181 char *service = NULL;
183 struct smbXsrv_tcon *tcon;
184 NTTIME now = timeval_to_nttime(&req->request_time);
185 connection_struct *compat_conn = NULL;
186 struct user_struct *compat_vuser = req->session->compat;
189 if (strncmp(share, "\\\\", 2) == 0) {
190 const char *p = strchr(share+2, '\\');
196 DEBUG(10,("smbd_smb2_tree_connect: path[%s] share[%s]\n",
199 service = talloc_strdup(talloc_tos(), share);
201 return NT_STATUS_NO_MEMORY;
206 /* TODO: do more things... */
207 if (strequal(service,HOMES_NAME)) {
208 if (compat_vuser->homes_snum == -1) {
209 DEBUG(2, ("[homes] share not available for "
210 "user %s because it was not found "
211 "or created at session setup "
213 compat_vuser->session_info->unix_info->unix_name));
214 return NT_STATUS_BAD_NETWORK_NAME;
216 snum = compat_vuser->homes_snum;
217 } else if ((compat_vuser->homes_snum != -1)
219 lp_servicename(talloc_tos(), compat_vuser->homes_snum))) {
220 snum = compat_vuser->homes_snum;
222 snum = find_service(talloc_tos(), service, &service);
224 return NT_STATUS_NO_MEMORY;
229 DEBUG(3,("smbd_smb2_tree_connect: couldn't find service %s\n",
231 return NT_STATUS_BAD_NETWORK_NAME;
234 if (lp_smb_encrypt(snum) == SMB_SIGNING_REQUIRED) {
235 status = NT_STATUS_ACCESS_DENIED;
236 DEBUG(3,("smbd_smb2_tree_connect: "
237 "service %s needs encryption - %s\n",
238 service, nt_errstr(status)));
242 /* create a new tcon as child of the session */
243 status = smb2srv_tcon_create(req->session, now, &tcon);
244 if (!NT_STATUS_IS_OK(status)) {
248 compat_conn = make_connection_smb2(req->sconn,
250 req->session->compat,
253 if (compat_conn == NULL) {
258 tcon->global->share_name = lp_servicename(tcon->global,
260 if (tcon->global->share_name == NULL) {
261 conn_free(compat_conn);
263 return NT_STATUS_NO_MEMORY;
266 tcon->compat = talloc_move(tcon, &compat_conn);
268 tcon->status = NT_STATUS_OK;
270 status = smbXsrv_tcon_update(tcon);
271 if (!NT_STATUS_IS_OK(status)) {
276 if (IS_PRINT(tcon->compat)) {
277 *out_share_type = SMB2_SHARE_TYPE_PRINT;
278 } else if (IS_IPC(tcon->compat)) {
279 *out_share_type = SMB2_SHARE_TYPE_PIPE;
281 *out_share_type = SMB2_SHARE_TYPE_DISK;
284 *out_share_flags = 0;
286 if (lp_msdfs_root(SNUM(tcon->compat)) && lp_host_msdfs()) {
287 *out_share_flags |= (SMB2_SHAREFLAG_DFS|SMB2_SHAREFLAG_DFS_ROOT);
288 *out_capabilities = SMB2_SHARE_CAP_DFS;
290 *out_capabilities = 0;
293 switch(lp_csc_policy(SNUM(tcon->compat))) {
294 case CSC_POLICY_MANUAL:
296 case CSC_POLICY_DOCUMENTS:
297 *out_share_flags |= SMB2_SHAREFLAG_AUTO_CACHING;
299 case CSC_POLICY_PROGRAMS:
300 *out_share_flags |= SMB2_SHAREFLAG_VDO_CACHING;
302 case CSC_POLICY_DISABLE:
303 *out_share_flags |= SMB2_SHAREFLAG_NO_CACHING;
309 if (lp_hideunreadable(SNUM(tcon->compat)) ||
310 lp_hideunwriteable_files(SNUM(tcon->compat))) {
311 *out_share_flags |= SMB2_SHAREFLAG_ACCESS_BASED_DIRECTORY_ENUM;
314 *out_maximal_access = tcon->compat->share_access;
316 *out_tree_id = tcon->global->tcon_wire_id;
320 struct smbd_smb2_tree_connect_state {
322 uint8_t out_share_type;
323 uint32_t out_share_flags;
324 uint32_t out_capabilities;
325 uint32_t out_maximal_access;
326 uint32_t out_tree_id;
329 static struct tevent_req *smbd_smb2_tree_connect_send(TALLOC_CTX *mem_ctx,
330 struct tevent_context *ev,
331 struct smbd_smb2_request *smb2req,
334 struct tevent_req *req;
335 struct smbd_smb2_tree_connect_state *state;
338 req = tevent_req_create(mem_ctx, &state,
339 struct smbd_smb2_tree_connect_state);
343 state->in_path = in_path;
345 status = smbd_smb2_tree_connect(smb2req,
347 &state->out_share_type,
348 &state->out_share_flags,
349 &state->out_capabilities,
350 &state->out_maximal_access,
351 &state->out_tree_id);
352 if (tevent_req_nterror(req, status)) {
353 return tevent_req_post(req, ev);
356 tevent_req_done(req);
357 return tevent_req_post(req, ev);
360 static NTSTATUS smbd_smb2_tree_connect_recv(struct tevent_req *req,
361 uint8_t *out_share_type,
362 uint32_t *out_share_flags,
363 uint32_t *out_capabilities,
364 uint32_t *out_maximal_access,
365 uint32_t *out_tree_id)
367 struct smbd_smb2_tree_connect_state *state =
369 struct smbd_smb2_tree_connect_state);
372 if (tevent_req_is_nterror(req, &status)) {
373 tevent_req_received(req);
377 *out_share_type = state->out_share_type;
378 *out_share_flags = state->out_share_flags;
379 *out_capabilities = state->out_capabilities;
380 *out_maximal_access = state->out_maximal_access;
381 *out_tree_id = state->out_tree_id;
383 tevent_req_received(req);
387 NTSTATUS smbd_smb2_request_process_tdis(struct smbd_smb2_request *req)
392 status = smbd_smb2_request_verify_sizes(req, 0x04);
393 if (!NT_STATUS_IS_OK(status)) {
394 return smbd_smb2_request_error(req, status);
398 * TODO: cancel all outstanding requests on the tcon
400 status = smbXsrv_tcon_disconnect(req->tcon, req->tcon->compat->vuid);
401 if (!NT_STATUS_IS_OK(status)) {
402 DEBUG(0, ("smbd_smb2_request_process_tdis: "
403 "smbXsrv_tcon_disconnect() failed: %s\n",
406 * If we hit this case, there is something completely
407 * wrong, so we better disconnect the transport connection.
412 TALLOC_FREE(req->tcon);
414 outbody = data_blob_talloc(req->out.vector, NULL, 0x04);
415 if (outbody.data == NULL) {
416 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
419 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
420 SSVAL(outbody.data, 0x02, 0); /* reserved */
422 return smbd_smb2_request_done(req, outbody, NULL);