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
;
158 if (strncmp(share
, "\\\\", 2) == 0) {
159 const char *p
= strchr(share
+2, '\\');
165 DEBUG(10,("smbd_smb2_tree_connect: path[%s] share[%s]\n",
168 fstrcpy(service
, share
);
172 snum
= find_service(service
);
174 DEBUG(3,("smbd_smb2_tree_connect: couldn't find service %s\n",
176 return NT_STATUS_BAD_NETWORK_NAME
;
179 /* TODO: do more things... */
181 /* create a new tcon as child of the session */
182 tcon
= talloc_zero(req
->session
, struct smbd_smb2_tcon
);
184 return NT_STATUS_NO_MEMORY
;
186 id
= idr_get_new_random(req
->session
->tcons
.idtree
,
188 req
->session
->tcons
.limit
);
191 return NT_STATUS_INSUFFICIENT_RESOURCES
;
196 DLIST_ADD_END(req
->session
->tcons
.list
, tcon
,
197 struct smbd_smb2_tcon
*);
198 tcon
->session
= req
->session
;
199 talloc_set_destructor(tcon
, smbd_smb2_tcon_destructor
);
201 compat_conn
= make_connection_snum(req
->sconn
,
202 snum
, req
->session
->compat_vuser
,
203 data_blob_null
, "???",
205 if (compat_conn
== NULL
) {
209 tcon
->compat_conn
= talloc_move(tcon
, &compat_conn
);
210 tcon
->compat_conn
->cnum
= tcon
->tid
;
212 if (IS_PRINT(tcon
->compat_conn
)) {
213 *out_share_type
= 0x03;
214 } else if (IS_IPC(tcon
->compat_conn
)) {
215 *out_share_type
= 0x02;
217 *out_share_type
= 0x01;
219 *out_share_flags
= SMB2_SHAREFLAG_ALL
;
220 *out_capabilities
= 0;
221 *out_maximal_access
= FILE_GENERIC_ALL
;
223 *out_tree_id
= tcon
->tid
;
227 NTSTATUS
smbd_smb2_request_check_tcon(struct smbd_smb2_request
*req
)
229 const uint8_t *inhdr
;
230 const uint8_t *outhdr
;
231 int i
= req
->current_idx
;
234 struct smbd_smb2_tcon
*tcon
;
235 bool chained_fixup
= false;
237 inhdr
= (const uint8_t *)req
->in
.vector
[i
+0].iov_base
;
239 in_tid
= IVAL(inhdr
, SMB2_HDR_TID
);
241 if (in_tid
== (0xFFFFFFFF)) {
244 * async request - fill in tid from
245 * already setup out.vector[].iov_base.
247 outhdr
= (const uint8_t *)req
->out
.vector
[i
].iov_base
;
248 in_tid
= IVAL(outhdr
, SMB2_HDR_TID
);
251 * Chained request - fill in tid from
252 * the previous request out.vector[].iov_base.
254 outhdr
= (const uint8_t *)req
->out
.vector
[i
-3].iov_base
;
255 in_tid
= IVAL(outhdr
, SMB2_HDR_TID
);
256 chained_fixup
= true;
260 /* lookup an existing session */
261 p
= idr_find(req
->session
->tcons
.idtree
, in_tid
);
263 return NT_STATUS_NETWORK_NAME_DELETED
;
265 tcon
= talloc_get_type_abort(p
, struct smbd_smb2_tcon
);
267 if (!change_to_user(tcon
->compat_conn
,req
->session
->vuid
)) {
268 return NT_STATUS_ACCESS_DENIED
;
271 /* should we pass FLAG_CASELESS_PATHNAMES here? */
272 if (!set_current_service(tcon
->compat_conn
, 0, true)) {
273 return NT_STATUS_ACCESS_DENIED
;
279 /* Fix up our own outhdr. */
280 outhdr
= (const uint8_t *)req
->out
.vector
[i
].iov_base
;
281 SIVAL(outhdr
, SMB2_HDR_TID
, in_tid
);
287 NTSTATUS
smbd_smb2_request_process_tdis(struct smbd_smb2_request
*req
)
289 const uint8_t *inbody
;
290 int i
= req
->current_idx
;
292 size_t expected_body_size
= 0x04;
295 if (req
->in
.vector
[i
+1].iov_len
!= (expected_body_size
& 0xFFFFFFFE)) {
296 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
299 inbody
= (const uint8_t *)req
->in
.vector
[i
+1].iov_base
;
301 body_size
= SVAL(inbody
, 0x00);
302 if (body_size
!= expected_body_size
) {
303 return smbd_smb2_request_error(req
, NT_STATUS_INVALID_PARAMETER
);
307 * TODO: cancel all outstanding requests on the tcon
308 * and delete all file handles.
310 TALLOC_FREE(req
->tcon
);
312 outbody
= data_blob_talloc(req
->out
.vector
, NULL
, 0x04);
313 if (outbody
.data
== NULL
) {
314 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
317 SSVAL(outbody
.data
, 0x00, 0x04); /* struct size */
318 SSVAL(outbody
.data
, 0x02, 0); /* reserved */
320 return smbd_smb2_request_done(req
, outbody
, NULL
);