source: branches/samba-3.5.x/source3/smbd/smb2_tcon.c

Last change on this file was 773, checked in by Herwig Bauernfeind, 12 years ago

Samba Server 3.5: Update branch to 3.5.20
File size: 7.7 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Core SMB2 server
4
5 Copyright (C) Stefan Metzmacher 2009
6
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.
11
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.
16
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/>.
19*/
20
21#include "includes.h"
22#include "smbd/globals.h"
23#include "../libcli/smb/smb_common.h"
24
25static NTSTATUS smbd_smb2_tree_connect(struct smbd_smb2_request *req,
26 const char *in_path,
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);
32
33NTSTATUS smbd_smb2_request_process_tcon(struct smbd_smb2_request *req)
34{
35 const uint8_t *inbody;
36 int i = req->current_idx;
37 uint8_t *outhdr;
38 DATA_BLOB outbody;
39 size_t expected_body_size = 0x09;
40 size_t body_size;
41 uint16_t in_path_offset;
42 uint16_t in_path_length;
43 DATA_BLOB in_path_buffer;
44 char *in_path_string;
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;
50 uint32_t out_tree_id;
51 NTSTATUS status;
52 bool ok;
53
54 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
55 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
56 }
57
58 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
59
60 body_size = SVAL(inbody, 0x00);
61 if (body_size != expected_body_size) {
62 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
63 }
64
65 in_path_offset = SVAL(inbody, 0x04);
66 in_path_length = SVAL(inbody, 0x06);
67
68 if (in_path_offset != (SMB2_HDR_BODY + (body_size & 0xFFFFFFFE))) {
69 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
70 }
71
72 if (in_path_length > req->in.vector[i+2].iov_len) {
73 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
74 }
75
76 in_path_buffer.data = (uint8_t *)req->in.vector[i+2].iov_base;
77 in_path_buffer.length = in_path_length;
78
79 ok = convert_string_talloc(req, CH_UTF16, CH_UNIX,
80 in_path_buffer.data,
81 in_path_buffer.length,
82 &in_path_string,
83 &in_path_string_size, false);
84 if (!ok) {
85 return smbd_smb2_request_error(req, NT_STATUS_ILLEGAL_CHARACTER);
86 }
87
88 status = smbd_smb2_tree_connect(req, in_path_string,
89 &out_share_type,
90 &out_share_flags,
91 &out_capabilities,
92 &out_maximal_access,
93 &out_tree_id);
94 if (!NT_STATUS_IS_OK(status)) {
95 return smbd_smb2_request_error(req, status);
96 }
97
98 outhdr = (uint8_t *)req->out.vector[i].iov_base;
99
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);
103 }
104
105 SIVAL(outhdr, SMB2_HDR_TID, out_tree_id);
106
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 */
117
118 return smbd_smb2_request_done(req, outbody, NULL);
119}
120
121static int smbd_smb2_tcon_destructor(struct smbd_smb2_tcon *tcon)
122{
123 if (tcon->session == NULL) {
124 return 0;
125 }
126
127 idr_remove(tcon->session->tcons.idtree, tcon->tid);
128 DLIST_REMOVE(tcon->session->tcons.list, tcon);
129
130 if (tcon->compat_conn) {
131 conn_free(tcon->compat_conn);
132 }
133
134 tcon->compat_conn = NULL;
135 tcon->tid = 0;
136 tcon->session = NULL;
137
138 return 0;
139}
140
141static NTSTATUS smbd_smb2_tree_connect(struct smbd_smb2_request *req,
142 const char *in_path,
143 uint8_t *out_share_type,
144 uint32_t *out_share_flags,
145 uint32_t *out_capabilities,
146 uint32_t *out_maximal_access,
147 uint32_t *out_tree_id)
148{
149 const char *share = in_path;
150 fstring service;
151 int snum = -1;
152 struct smbd_smb2_tcon *tcon;
153 int id;
154 NTSTATUS status;
155
156 if (strncmp(share, "\\\\", 2) == 0) {
157 const char *p = strchr(share+2, '\\');
158 if (p) {
159 share = p + 1;
160 }
161 }
162
163 DEBUG(10,("smbd_smb2_tree_connect: path[%s] share[%s]\n",
164 in_path, share));
165
166 fstrcpy(service, share);
167
168 strlower_m(service);
169
170 snum = find_service(service, service);
171 if (snum < 0) {
172 DEBUG(3,("smbd_smb2_tree_connect: couldn't find service %s\n",
173 service));
174 return NT_STATUS_BAD_NETWORK_NAME;
175 }
176
177 /* TODO: do more things... */
178
179 /* create a new tcon as child of the session */
180 tcon = talloc_zero(req->session, struct smbd_smb2_tcon);
181 if (tcon == NULL) {
182 return NT_STATUS_NO_MEMORY;
183 }
184 id = idr_get_new_random(req->session->tcons.idtree,
185 tcon,
186 req->session->tcons.limit);
187 if (id == -1) {
188 TALLOC_FREE(tcon);
189 return NT_STATUS_INSUFFICIENT_RESOURCES;
190 }
191 tcon->tid = id;
192 tcon->snum = snum;
193
194 DLIST_ADD_END(req->session->tcons.list, tcon,
195 struct smbd_smb2_tcon *);
196 tcon->session = req->session;
197 talloc_set_destructor(tcon, smbd_smb2_tcon_destructor);
198
199 tcon->compat_conn = make_connection_snum(req->sconn,
200 snum, req->session->compat_vuser,
201 data_blob_null, "???",
202 &status);
203 if (tcon->compat_conn == NULL) {
204 TALLOC_FREE(tcon);
205 return status;
206 }
207 tcon->compat_conn->cnum = tcon->tid;
208
209 *out_share_type = 0x01;
210 *out_share_flags = SMB2_SHAREFLAG_ALL;
211 *out_capabilities = 0;
212 *out_maximal_access = FILE_GENERIC_ALL;
213
214 *out_tree_id = tcon->tid;
215 return NT_STATUS_OK;
216}
217
218NTSTATUS smbd_smb2_request_check_tcon(struct smbd_smb2_request *req)
219{
220 const uint8_t *inhdr;
221 int i = req->current_idx;
222 uint32_t in_tid;
223 void *p;
224 struct smbd_smb2_tcon *tcon;
225
226 inhdr = (const uint8_t *)req->in.vector[i+0].iov_base;
227
228 in_tid = IVAL(inhdr, SMB2_HDR_TID);
229
230 /* lookup an existing session */
231 p = idr_find(req->session->tcons.idtree, in_tid);
232 if (p == NULL) {
233 return NT_STATUS_NETWORK_NAME_DELETED;
234 }
235 tcon = talloc_get_type_abort(p, struct smbd_smb2_tcon);
236
237 if (!change_to_user(tcon->compat_conn,req->session->vuid)) {
238 return NT_STATUS_ACCESS_DENIED;
239 }
240
241 /* should we pass FLAG_CASELESS_PATHNAMES here? */
242 if (!set_current_service(tcon->compat_conn, 0, true)) {
243 return NT_STATUS_ACCESS_DENIED;
244 }
245
246 req->tcon = tcon;
247 return NT_STATUS_OK;
248}
249
250NTSTATUS smbd_smb2_request_process_tdis(struct smbd_smb2_request *req)
251{
252 const uint8_t *inbody;
253 int i = req->current_idx;
254 DATA_BLOB outbody;
255 size_t expected_body_size = 0x04;
256 size_t body_size;
257
258 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
259 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
260 }
261
262 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
263
264 body_size = SVAL(inbody, 0x00);
265 if (body_size != expected_body_size) {
266 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
267 }
268
269 /*
270 * TODO: cancel all outstanding requests on the tcon
271 * and delete all file handles.
272 */
273 TALLOC_FREE(req->tcon);
274
275 outbody = data_blob_talloc(req->out.vector, NULL, 0x04);
276 if (outbody.data == NULL) {
277 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
278 }
279
280 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
281 SSVAL(outbody.data, 0x02, 0); /* reserved */
282
283 return smbd_smb2_request_done(req, outbody, NULL);
284}
Note: See TracBrowser for help on using the repository browser.