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/globals.h"
23 #include "../libcli/smb/smb_common.h"
25 static NTSTATUS smbd_smb2_tree_connect(struct smbd_smb2_request *req,
27 uint8_t *out_share_type,
28 uint32_t *out_share_flags,
29 uint32_t *out_capabilities,
30 uint32_t *out_maximal_access,
31 uint32_t *out_tree_id);
33 NTSTATUS smbd_smb2_request_process_tcon(struct smbd_smb2_request *req)
35 const uint8_t *inbody;
36 int i = req->current_idx;
39 size_t expected_body_size = 0x09;
41 uint16_t in_path_offset;
42 uint16_t in_path_length;
43 DATA_BLOB in_path_buffer;
45 size_t in_path_string_size;
46 uint8_t out_share_type;
47 uint32_t out_share_flags;
48 uint32_t out_capabilities;
49 uint32_t out_maximal_access;
54 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
55 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
58 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
60 body_size = SVAL(inbody, 0x00);
61 if (body_size != expected_body_size) {
62 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
65 in_path_offset = SVAL(inbody, 0x04);
66 in_path_length = SVAL(inbody, 0x06);
68 if (in_path_offset != (SMB2_HDR_BODY + (body_size & 0xFFFFFFFE))) {
69 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
72 if (in_path_length > req->in.vector[i+2].iov_len) {
73 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
76 in_path_buffer.data = (uint8_t *)req->in.vector[i+2].iov_base;
77 in_path_buffer.length = in_path_length;
79 ok = convert_string_talloc(req, CH_UTF16, CH_UNIX,
81 in_path_buffer.length,
83 &in_path_string_size, false);
85 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
88 status = smbd_smb2_tree_connect(req, in_path_string,
94 if (!NT_STATUS_IS_OK(status)) {
95 return smbd_smb2_request_error(req, status);
98 outhdr = (uint8_t *)req->out.vector[i].iov_base;
100 outbody = data_blob_talloc(req->out.vector, NULL, 0x10);
101 if (outbody.data == NULL) {
102 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
105 SIVAL(outhdr, SMB2_HDR_TID, out_tree_id);
107 SSVAL(outbody.data, 0x00, 0x10); /* struct size */
108 SCVAL(outbody.data, 0x02,
109 out_share_type); /* share type */
110 SCVAL(outbody.data, 0x03, 0); /* reserved */
111 SIVAL(outbody.data, 0x04,
112 out_share_flags); /* share flags */
113 SIVAL(outbody.data, 0x08,
114 out_capabilities); /* capabilities */
115 SIVAL(outbody.data, 0x0C,
116 out_maximal_access); /* maximal access */
118 return smbd_smb2_request_done(req, outbody, NULL);
121 static int smbd_smb2_tcon_destructor(struct smbd_smb2_tcon *tcon)
123 if (tcon->session == NULL) {
127 idr_remove(tcon->session->tcons.idtree, tcon->tid);
128 DLIST_REMOVE(tcon->session->tcons.list, tcon);
130 if (tcon->compat_conn) {
131 set_current_service(tcon->compat_conn, 0, true);
132 close_cnum(tcon->compat_conn, tcon->session->vuid);
135 tcon->compat_conn = NULL;
137 tcon->session = NULL;
142 static NTSTATUS smbd_smb2_tree_connect(struct smbd_smb2_request *req,
144 uint8_t *out_share_type,
145 uint32_t *out_share_flags,
146 uint32_t *out_capabilities,
147 uint32_t *out_maximal_access,
148 uint32_t *out_tree_id)
150 const char *share = in_path;
153 struct smbd_smb2_tcon *tcon;
154 connection_struct *compat_conn = NULL;
155 user_struct *compat_vuser = req->session->compat_vuser;
159 if (strncmp(share, "\\\\", 2) == 0) {
160 const char *p = strchr(share+2, '\\');
166 DEBUG(10,("smbd_smb2_tree_connect: path[%s] share[%s]\n",
169 fstrcpy(service, share);
173 /* TODO: do more things... */
174 if (strequal(service,HOMES_NAME)) {
175 if (compat_vuser->homes_snum == -1) {
176 DEBUG(2, ("[homes] share not available for "
177 "user %s because it was not found "
178 "or created at session setup "
180 compat_vuser->server_info->unix_name));
181 return NT_STATUS_BAD_NETWORK_NAME;
183 snum = compat_vuser->homes_snum;
184 } else if ((compat_vuser->homes_snum != -1)
186 lp_servicename(compat_vuser->homes_snum))) {
187 snum = compat_vuser->homes_snum;
189 snum = find_service(service);
193 DEBUG(3,("smbd_smb2_tree_connect: couldn't find service %s\n",
195 return NT_STATUS_BAD_NETWORK_NAME;
198 /* create a new tcon as child of the session */
199 tcon = talloc_zero(req->session, struct smbd_smb2_tcon);
201 return NT_STATUS_NO_MEMORY;
203 id = idr_get_new_random(req->session->tcons.idtree,
205 req->session->tcons.limit);
208 return NT_STATUS_INSUFFICIENT_RESOURCES;
213 DLIST_ADD_END(req->session->tcons.list, tcon,
214 struct smbd_smb2_tcon *);
215 tcon->session = req->session;
216 talloc_set_destructor(tcon, smbd_smb2_tcon_destructor);
218 compat_conn = make_connection_snum(req->sconn,
219 snum, req->session->compat_vuser,
220 data_blob_null, "???",
222 if (compat_conn == NULL) {
226 tcon->compat_conn = talloc_move(tcon, &compat_conn);
227 tcon->compat_conn->cnum = tcon->tid;
229 if (IS_PRINT(tcon->compat_conn)) {
230 *out_share_type = 0x03;
231 } else if (IS_IPC(tcon->compat_conn)) {
232 *out_share_type = 0x02;
234 *out_share_type = 0x01;
236 *out_share_flags = SMB2_SHAREFLAG_ALL;
237 *out_capabilities = 0;
238 *out_maximal_access = FILE_GENERIC_ALL;
240 *out_tree_id = tcon->tid;
244 NTSTATUS smbd_smb2_request_check_tcon(struct smbd_smb2_request *req)
246 const uint8_t *inhdr;
247 const uint8_t *outhdr;
248 int i = req->current_idx;
251 struct smbd_smb2_tcon *tcon;
252 bool chained_fixup = false;
254 inhdr = (const uint8_t *)req->in.vector[i+0].iov_base;
256 in_tid = IVAL(inhdr, SMB2_HDR_TID);
258 if (in_tid == (0xFFFFFFFF)) {
261 * async request - fill in tid from
262 * already setup out.vector[].iov_base.
264 outhdr = (const uint8_t *)req->out.vector[i].iov_base;
265 in_tid = IVAL(outhdr, SMB2_HDR_TID);
268 * Chained request - fill in tid from
269 * the previous request out.vector[].iov_base.
271 outhdr = (const uint8_t *)req->out.vector[i-3].iov_base;
272 in_tid = IVAL(outhdr, SMB2_HDR_TID);
273 chained_fixup = true;
277 /* lookup an existing session */
278 p = idr_find(req->session->tcons.idtree, in_tid);
280 return NT_STATUS_NETWORK_NAME_DELETED;
282 tcon = talloc_get_type_abort(p, struct smbd_smb2_tcon);
284 if (!change_to_user(tcon->compat_conn,req->session->vuid)) {
285 return NT_STATUS_ACCESS_DENIED;
288 /* should we pass FLAG_CASELESS_PATHNAMES here? */
289 if (!set_current_service(tcon->compat_conn, 0, true)) {
290 return NT_STATUS_ACCESS_DENIED;
296 /* Fix up our own outhdr. */
297 outhdr = (const uint8_t *)req->out.vector[i].iov_base;
298 SIVAL(outhdr, SMB2_HDR_TID, in_tid);
304 NTSTATUS smbd_smb2_request_process_tdis(struct smbd_smb2_request *req)
306 const uint8_t *inbody;
307 int i = req->current_idx;
309 size_t expected_body_size = 0x04;
312 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
313 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
316 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
318 body_size = SVAL(inbody, 0x00);
319 if (body_size != expected_body_size) {
320 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
324 * TODO: cancel all outstanding requests on the tcon
325 * and delete all file handles.
327 TALLOC_FREE(req->tcon);
329 outbody = data_blob_talloc(req->out.vector, NULL, 0x04);
330 if (outbody.data == NULL) {
331 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
334 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
335 SSVAL(outbody.data, 0x02, 0); /* reserved */
337 return smbd_smb2_request_done(req, outbody, NULL);