source: branches/samba-3.5.x/source4/smb_server/smb2/tcon.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 12.6 KB
Line 
1/*
2 Unix SMB2 implementation.
3
4 Copyright (C) Stefan Metzmacher 2005
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21#include "libcli/smb2/smb2.h"
22#include "libcli/smb2/smb2_calls.h"
23#include "smb_server/smb_server.h"
24#include "smb_server/smb2/smb2_server.h"
25#include "smbd/service_stream.h"
26#include "ntvfs/ntvfs.h"
27
28/*
29 send an oplock break request to a client
30*/
31static NTSTATUS smb2srv_send_oplock_break(void *p, struct ntvfs_handle *h, uint8_t level)
32{
33 struct smbsrv_handle *handle = talloc_get_type(h->frontend_data.private_data,
34 struct smbsrv_handle);
35 struct smb2srv_request *req;
36 NTSTATUS status;
37
38 /* setup a dummy request structure */
39 req = smb2srv_init_request(handle->tcon->smb_conn);
40 NT_STATUS_HAVE_NO_MEMORY(req);
41
42 req->in.buffer = talloc_array(req, uint8_t,
43 NBT_HDR_SIZE + SMB2_MIN_SIZE);
44 NT_STATUS_HAVE_NO_MEMORY(req->in.buffer);
45 req->in.size = NBT_HDR_SIZE + SMB2_MIN_SIZE;
46 req->in.allocated = req->in.size;
47
48 req->in.hdr = req->in.buffer+ NBT_HDR_SIZE;
49 req->in.body = req->in.hdr + SMB2_HDR_BODY;
50 req->in.body_size = req->in.size - (SMB2_HDR_BODY+NBT_HDR_SIZE);
51 req->in.dynamic = NULL;
52
53 req->seqnum = UINT64_MAX;
54
55 smb2srv_setup_bufinfo(req);
56
57 SIVAL(req->in.hdr, 0, SMB2_MAGIC);
58 SSVAL(req->in.hdr, SMB2_HDR_LENGTH, SMB2_HDR_BODY);
59 SSVAL(req->in.hdr, SMB2_HDR_EPOCH, 0);
60 SIVAL(req->in.hdr, SMB2_HDR_STATUS, 0);
61 SSVAL(req->in.hdr, SMB2_HDR_OPCODE, SMB2_OP_BREAK);
62 SSVAL(req->in.hdr, SMB2_HDR_CREDIT, 0);
63 SIVAL(req->in.hdr, SMB2_HDR_FLAGS, 0);
64 SIVAL(req->in.hdr, SMB2_HDR_NEXT_COMMAND, 0);
65 SBVAL(req->in.hdr, SMB2_HDR_MESSAGE_ID, 0);
66 SIVAL(req->in.hdr, SMB2_HDR_PID, 0);
67 SIVAL(req->in.hdr, SMB2_HDR_TID, 0);
68 SBVAL(req->in.hdr, SMB2_HDR_SESSION_ID, 0);
69 memset(req->in.hdr+SMB2_HDR_SIGNATURE, 0, 16);
70
71 SSVAL(req->in.body, 0, 2);
72
73 status = smb2srv_setup_reply(req, 0x18, false, 0);
74 NT_STATUS_NOT_OK_RETURN(status);
75
76 SSVAL(req->out.hdr, SMB2_HDR_CREDIT, 0x0000);
77
78 SSVAL(req->out.body, 0x02, 0x0001);
79 SIVAL(req->out.body, 0x04, 0x00000000);
80 smb2srv_push_handle(req->out.body, 0x08, h);
81
82 smb2srv_send_reply(req);
83
84 return NT_STATUS_OK;
85}
86
87struct ntvfs_handle *smb2srv_pull_handle(struct smb2srv_request *req, const uint8_t *base, uint_t offset)
88{
89 struct smbsrv_tcon *tcon;
90 struct smbsrv_handle *handle;
91 uint32_t hid;
92 uint32_t tid;
93 uint64_t uid;
94
95 /*
96 * if there're chained requests used the cached handle
97 *
98 * TODO: check if this also correct when the given handle
99 * isn't all 0xFF.
100 */
101 if (req->chained_file_handle) {
102 base = req->chained_file_handle;
103 offset = 0;
104 }
105
106 hid = IVAL(base, offset);
107 tid = IVAL(base, offset + 4);
108 uid = BVAL(base, offset + 8);
109
110 /* if it's the wildcard handle, don't waste time to search it... */
111 if (hid == UINT32_MAX && tid == UINT32_MAX && uid == UINT64_MAX) {
112 return NULL;
113 }
114
115 /*
116 * if the (v)uid part doesn't match the given session the handle isn't
117 * valid
118 */
119 if (uid != req->session->vuid) {
120 return NULL;
121 }
122
123 /*
124 * the handle can belong to a different tcon
125 * as that TID in the SMB2 header says, but
126 * the request should succeed nevertheless!
127 *
128 * because of this we put the 32 bit TID into the
129 * 128 bit handle, so that we can extract the tcon from the
130 * handle
131 */
132 tcon = req->tcon;
133 if (tid != req->tcon->tid) {
134 tcon = smbsrv_smb2_tcon_find(req->session, tid, req->request_time);
135 if (!tcon) {
136 return NULL;
137 }
138 }
139
140 handle = smbsrv_smb2_handle_find(tcon, hid, req->request_time);
141 if (!handle) {
142 return NULL;
143 }
144
145 /*
146 * as the smb2srv_tcon is a child object of the smb2srv_session
147 * the handle belongs to the correct session!
148 *
149 * Note: no check is needed here for SMB2
150 */
151
152 /*
153 * as the handle may have overwritten the tcon
154 * we need to set it on the request so that the
155 * correct ntvfs context will be used for the ntvfs_*() request
156 *
157 * TODO: check if that's correct for chained requests as well!
158 */
159 req->tcon = tcon;
160 return handle->ntvfs;
161}
162
163void smb2srv_push_handle(uint8_t *base, uint_t offset, struct ntvfs_handle *ntvfs)
164{
165 struct smbsrv_handle *handle = talloc_get_type(ntvfs->frontend_data.private_data,
166 struct smbsrv_handle);
167
168 /*
169 * the handle is 128 bit on the wire
170 */
171 SIVAL(base, offset, handle->hid);
172 SIVAL(base, offset + 4, handle->tcon->tid);
173 SBVAL(base, offset + 8, handle->session->vuid);
174}
175
176static NTSTATUS smb2srv_handle_create_new(void *private_data, struct ntvfs_request *ntvfs, struct ntvfs_handle **_h)
177{
178 struct smb2srv_request *req = talloc_get_type(ntvfs->frontend_data.private_data,
179 struct smb2srv_request);
180 struct smbsrv_handle *handle;
181 struct ntvfs_handle *h;
182
183 handle = smbsrv_handle_new(req->session, req->tcon, req, req->request_time);
184 if (!handle) return NT_STATUS_INSUFFICIENT_RESOURCES;
185
186 h = talloc_zero(handle, struct ntvfs_handle);
187 if (!h) goto nomem;
188
189 /*
190 * note: we don't set handle->ntvfs yet,
191 * this will be done by smbsrv_handle_make_valid()
192 * this makes sure the handle is invalid for clients
193 * until the ntvfs subsystem has made it valid
194 */
195 h->ctx = ntvfs->ctx;
196 h->session_info = ntvfs->session_info;
197 h->smbpid = ntvfs->smbpid;
198
199 h->frontend_data.private_data = handle;
200
201 *_h = h;
202 return NT_STATUS_OK;
203nomem:
204 talloc_free(handle);
205 return NT_STATUS_NO_MEMORY;
206}
207
208static NTSTATUS smb2srv_handle_make_valid(void *private_data, struct ntvfs_handle *h)
209{
210 struct smbsrv_tcon *tcon = talloc_get_type(private_data, struct smbsrv_tcon);
211 struct smbsrv_handle *handle = talloc_get_type(h->frontend_data.private_data,
212 struct smbsrv_handle);
213 /* this tells the frontend that the handle is valid */
214 handle->ntvfs = h;
215 /* this moves the smbsrv_request to the smbsrv_tcon memory context */
216 talloc_steal(tcon, handle);
217 return NT_STATUS_OK;
218}
219
220static void smb2srv_handle_destroy(void *private_data, struct ntvfs_handle *h)
221{
222 struct smbsrv_handle *handle = talloc_get_type(h->frontend_data.private_data,
223 struct smbsrv_handle);
224 talloc_free(handle);
225}
226
227static struct ntvfs_handle *smb2srv_handle_search_by_wire_key(void *private_data, struct ntvfs_request *ntvfs, const DATA_BLOB *key)
228{
229 return NULL;
230}
231
232static DATA_BLOB smb2srv_handle_get_wire_key(void *private_data, struct ntvfs_handle *handle, TALLOC_CTX *mem_ctx)
233{
234 return data_blob(NULL, 0);
235}
236
237static NTSTATUS smb2srv_tcon_backend(struct smb2srv_request *req, union smb_tcon *io)
238{
239 struct smbsrv_tcon *tcon;
240 NTSTATUS status;
241 enum ntvfs_type type;
242 const char *service = io->smb2.in.path;
243 struct share_config *scfg;
244 const char *sharetype;
245 uint64_t ntvfs_caps = 0;
246
247 if (strncmp(service, "\\\\", 2) == 0) {
248 const char *p = strchr(service+2, '\\');
249 if (p) {
250 service = p + 1;
251 }
252 }
253
254 status = share_get_config(req, req->smb_conn->share_context, service, &scfg);
255 if (!NT_STATUS_IS_OK(status)) {
256 DEBUG(0,("smb2srv_tcon_backend: couldn't find service %s\n", service));
257 return NT_STATUS_BAD_NETWORK_NAME;
258 }
259
260 if (!socket_check_access(req->smb_conn->connection->socket,
261 scfg->name,
262 share_string_list_option(req, scfg, SHARE_HOSTS_ALLOW),
263 share_string_list_option(req, scfg, SHARE_HOSTS_DENY))) {
264 return NT_STATUS_ACCESS_DENIED;
265 }
266
267 /* work out what sort of connection this is */
268 sharetype = share_string_option(scfg, SHARE_TYPE, "DISK");
269 if (sharetype && strcmp(sharetype, "IPC") == 0) {
270 type = NTVFS_IPC;
271 } else if (sharetype && strcmp(sharetype, "PRINTER") == 0) {
272 type = NTVFS_PRINT;
273 } else {
274 type = NTVFS_DISK;
275 }
276
277 tcon = smbsrv_smb2_tcon_new(req->session, scfg->name);
278 if (!tcon) {
279 DEBUG(0,("smb2srv_tcon_backend: Couldn't find free connection.\n"));
280 return NT_STATUS_INSUFFICIENT_RESOURCES;
281 }
282 req->tcon = tcon;
283
284 ntvfs_caps = NTVFS_CLIENT_CAP_LEVEL_II_OPLOCKS;
285
286 /* init ntvfs function pointers */
287 status = ntvfs_init_connection(tcon, scfg, type,
288 req->smb_conn->negotiate.protocol,
289 ntvfs_caps,
290 req->smb_conn->connection->event.ctx,
291 req->smb_conn->connection->msg_ctx,
292 req->smb_conn->lp_ctx,
293 req->smb_conn->connection->server_id,
294 &tcon->ntvfs);
295 if (!NT_STATUS_IS_OK(status)) {
296 DEBUG(0, ("smb2srv_tcon_backend: ntvfs_init_connection failed for service %s\n",
297 scfg->name));
298 goto failed;
299 }
300
301 status = ntvfs_set_oplock_handler(tcon->ntvfs, smb2srv_send_oplock_break, tcon);
302 if (!NT_STATUS_IS_OK(status)) {
303 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the oplock handler!\n"));
304 goto failed;
305 }
306
307 status = ntvfs_set_addr_callbacks(tcon->ntvfs, smbsrv_get_my_addr, smbsrv_get_peer_addr, req->smb_conn);
308 if (!NT_STATUS_IS_OK(status)) {
309 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the addr callbacks!\n"));
310 goto failed;
311 }
312
313 status = ntvfs_set_handle_callbacks(tcon->ntvfs,
314 smb2srv_handle_create_new,
315 smb2srv_handle_make_valid,
316 smb2srv_handle_destroy,
317 smb2srv_handle_search_by_wire_key,
318 smb2srv_handle_get_wire_key,
319 tcon);
320 if (!NT_STATUS_IS_OK(status)) {
321 DEBUG(0,("smb2srv_tcon_backend: NTVFS failed to set the handle callbacks!\n"));
322 goto failed;
323 }
324
325 req->ntvfs = ntvfs_request_create(req->tcon->ntvfs, req,
326 req->session->session_info,
327 SVAL(req->in.hdr, SMB2_HDR_PID),
328 req->request_time,
329 req, NULL, 0);
330 if (!req->ntvfs) {
331 status = NT_STATUS_NO_MEMORY;
332 goto failed;
333 }
334
335 io->smb2.out.share_type = (unsigned)type; /* 1 - DISK, 2 - Print, 3 - IPC */
336 io->smb2.out.reserved = 0;
337 io->smb2.out.flags = 0x00000000;
338 io->smb2.out.capabilities = 0;
339 io->smb2.out.access_mask = SEC_RIGHTS_FILE_ALL;
340
341 io->smb2.out.tid = tcon->tid;
342
343 /* Invoke NTVFS connection hook */
344 status = ntvfs_connect(req->ntvfs, io);
345 if (!NT_STATUS_IS_OK(status)) {
346 DEBUG(0,("smb2srv_tcon_backend: NTVFS ntvfs_connect() failed!\n"));
347 goto failed;
348 }
349
350 return NT_STATUS_OK;
351
352failed:
353 req->tcon = NULL;
354 talloc_free(tcon);
355 return status;
356}
357
358static void smb2srv_tcon_send(struct smb2srv_request *req, union smb_tcon *io)
359{
360 uint16_t credit;
361
362 if (!NT_STATUS_IS_OK(req->status)) {
363 smb2srv_send_error(req, req->status);
364 return;
365 }
366 if (io->smb2.out.share_type == NTVFS_IPC) {
367 /* if it's an IPC share vista returns 0x0005 */
368 credit = 0x0005;
369 } else {
370 credit = 0x0001;
371 }
372
373 SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, false, 0));
374
375 SIVAL(req->out.hdr, SMB2_HDR_TID, io->smb2.out.tid);
376 SSVAL(req->out.hdr, SMB2_HDR_CREDIT,credit);
377
378 SCVAL(req->out.body, 0x02, io->smb2.out.share_type);
379 SCVAL(req->out.body, 0x03, io->smb2.out.reserved);
380 SIVAL(req->out.body, 0x04, io->smb2.out.flags);
381 SIVAL(req->out.body, 0x08, io->smb2.out.capabilities);
382 SIVAL(req->out.body, 0x0C, io->smb2.out.access_mask);
383
384 smb2srv_send_reply(req);
385}
386
387void smb2srv_tcon_recv(struct smb2srv_request *req)
388{
389 union smb_tcon *io;
390
391 SMB2SRV_CHECK_BODY_SIZE(req, 0x08, true);
392 SMB2SRV_TALLOC_IO_PTR(io, union smb_tcon);
393
394 io->smb2.level = RAW_TCON_SMB2;
395 io->smb2.in.reserved = SVAL(req->in.body, 0x02);
396 SMB2SRV_CHECK(smb2_pull_o16s16_string(&req->in, io, req->in.body+0x04, &io->smb2.in.path));
397
398 /* the VFS backend does not yet handle NULL paths */
399 if (io->smb2.in.path == NULL) {
400 io->smb2.in.path = "";
401 }
402
403 req->status = smb2srv_tcon_backend(req, io);
404
405 if (req->control_flags & SMB2SRV_REQ_CTRL_FLAG_NOT_REPLY) {
406 talloc_free(req);
407 return;
408 }
409 smb2srv_tcon_send(req, io);
410}
411
412static NTSTATUS smb2srv_tdis_backend(struct smb2srv_request *req)
413{
414 /* TODO: call ntvfs backends to close file of this tcon */
415 talloc_free(req->tcon);
416 req->tcon = NULL;
417 return NT_STATUS_OK;
418}
419
420static void smb2srv_tdis_send(struct smb2srv_request *req)
421{
422 NTSTATUS status;
423
424 if (NT_STATUS_IS_ERR(req->status)) {
425 smb2srv_send_error(req, req->status);
426 return;
427 }
428
429 status = smb2srv_setup_reply(req, 0x04, false, 0);
430 if (!NT_STATUS_IS_OK(status)) {
431 smbsrv_terminate_connection(req->smb_conn, nt_errstr(status));
432 talloc_free(req);
433 return;
434 }
435
436 SSVAL(req->out.body, 0x02, 0);
437
438 smb2srv_send_reply(req);
439}
440
441void smb2srv_tdis_recv(struct smb2srv_request *req)
442{
443 uint16_t _pad;
444
445 SMB2SRV_CHECK_BODY_SIZE(req, 0x04, false);
446
447 _pad = SVAL(req->in.body, 0x02);
448
449 req->status = smb2srv_tdis_backend(req);
450
451 if (req->control_flags & SMB2SRV_REQ_CTRL_FLAG_NOT_REPLY) {
452 talloc_free(req);
453 return;
454 }
455 smb2srv_tdis_send(req);
456}
Note: See TracBrowser for help on using the repository browser.