2 Unix SMB2 implementation.
4 Copyright (C) Andrew Bartlett 2001-2005
5 Copyright (C) Stefan Metzmacher 2005
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 "auth/credentials/credentials.h"
23 #include "auth/gensec/gensec.h"
24 #include "auth/auth.h"
25 #include "libcli/smb2/smb2.h"
26 #include "libcli/smb2/smb2_calls.h"
27 #include "smb_server/smb_server.h"
28 #include "smb_server/service_smb_proto.h"
29 #include "smb_server/smb2/smb2_server.h"
30 #include "smbd/service_stream.h"
32 static void smb2srv_sesssetup_send(struct smb2srv_request *req, union smb_sesssetup *io)
36 if (NT_STATUS_IS_OK(req->status)) {
38 } else if (NT_STATUS_EQUAL(req->status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
41 smb2srv_send_error(req, req->status);
45 SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x08, True, io->smb2.out.secblob.length));
47 SSVAL(req->out.hdr, SMB2_HDR_UNKNOWN1, unknown1);
48 SBVAL(req->out.hdr, SMB2_HDR_UID, io->smb2.out.uid);
50 SSVAL(req->out.body, 0x02, io->smb2.out._pad);
51 SMB2SRV_CHECK(smb2_push_o16s16_blob(&req->out, 0x04, io->smb2.out.secblob));
53 smb2srv_send_reply(req);
56 struct smb2srv_sesssetup_callback_ctx {
57 struct smb2srv_request *req;
58 union smb_sesssetup *io;
59 struct smbsrv_session *smb_sess;
62 static void smb2srv_sesssetup_callback(struct gensec_update_request *greq, void *private_data)
64 struct smb2srv_sesssetup_callback_ctx *ctx = talloc_get_type(private_data,
65 struct smb2srv_sesssetup_callback_ctx);
66 struct smb2srv_request *req = ctx->req;
67 union smb_sesssetup *io = ctx->io;
68 struct smbsrv_session *smb_sess = ctx->smb_sess;
69 struct auth_session_info *session_info = NULL;
72 status = gensec_update_recv(greq, req, &io->smb2.out.secblob);
73 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
75 } else if (!NT_STATUS_IS_OK(status)) {
79 status = gensec_session_info(smb_sess->gensec_ctx, &session_info);
80 if (!NT_STATUS_IS_OK(status)) {
84 /* Ensure this is marked as a 'real' vuid, not one
85 * simply valid for the session setup leg */
86 status = smbsrv_session_sesssetup_finished(smb_sess, session_info);
87 if (!NT_STATUS_IS_OK(status)) {
90 req->session = smb_sess;
93 io->smb2.out.uid = smb_sess->vuid;
95 req->status = auth_nt_status_squash(status);
96 smb2srv_sesssetup_send(req, io);
97 if (!NT_STATUS_IS_OK(status) && !
98 NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
99 talloc_free(smb_sess);
103 static void smb2srv_sesssetup_backend(struct smb2srv_request *req, union smb_sesssetup *io)
106 struct smb2srv_sesssetup_callback_ctx *callback_ctx;
107 struct smbsrv_session *smb_sess = NULL;
110 io->smb2.out._pad = 0;
111 io->smb2.out.uid = 0;
112 io->smb2.out.secblob = data_blob(NULL, 0);
114 vuid = BVAL(req->in.hdr, SMB2_HDR_UID);
117 * only when we got '0' we should allocate a new session
120 struct gensec_security *gensec_ctx;
122 status = gensec_server_start(req,
123 req->smb_conn->connection->event.ctx,
124 req->smb_conn->connection->msg_ctx,
126 if (!NT_STATUS_IS_OK(status)) {
127 DEBUG(1, ("Failed to start GENSEC server code: %s\n", nt_errstr(status)));
131 gensec_set_credentials(gensec_ctx, req->smb_conn->negotiate.server_credentials);
133 gensec_set_target_service(gensec_ctx, "cifs");
135 gensec_want_feature(gensec_ctx, GENSEC_FEATURE_SESSION_KEY);
137 status = gensec_start_mech_by_oid(gensec_ctx, GENSEC_OID_SPNEGO);
138 if (!NT_STATUS_IS_OK(status)) {
139 DEBUG(1, ("Failed to start GENSEC SPNEGO server code: %s\n", nt_errstr(status)));
143 /* allocate a new session */
144 smb_sess = smbsrv_session_new(req->smb_conn, req->smb_conn, gensec_ctx);
146 status = NT_STATUS_INSUFFICIENT_RESOURCES;
149 status = smbsrv_smb2_init_tcons(smb_sess);
150 if (!NT_STATUS_IS_OK(status)) {
154 /* lookup an existing session */
155 smb_sess = smbsrv_session_find_sesssetup(req->smb_conn, vuid);
159 status = NT_STATUS_USER_SESSION_DELETED;
163 if (!smb_sess->gensec_ctx) {
164 status = NT_STATUS_INTERNAL_ERROR;
165 DEBUG(1, ("Internal ERROR: no gensec_ctx on session: %s\n", nt_errstr(status)));
169 callback_ctx = talloc(req, struct smb2srv_sesssetup_callback_ctx);
170 if (!callback_ctx) goto nomem;
171 callback_ctx->req = req;
172 callback_ctx->io = io;
173 callback_ctx->smb_sess = smb_sess;
175 gensec_update_send(smb_sess->gensec_ctx, io->smb2.in.secblob,
176 smb2srv_sesssetup_callback, callback_ctx);
179 status = NT_STATUS_NO_MEMORY;
181 talloc_free(smb_sess);
182 req->status = auth_nt_status_squash(status);
183 smb2srv_sesssetup_send(req, io);
186 void smb2srv_sesssetup_recv(struct smb2srv_request *req)
188 union smb_sesssetup *io;
190 SMB2SRV_CHECK_BODY_SIZE(req, 0x18, True);
191 SMB2SRV_TALLOC_IO_PTR(io, union smb_sesssetup);
193 io->smb2.level = RAW_SESSSETUP_SMB2;
194 io->smb2.in._pad = SVAL(req->in.body, 0x02);
195 io->smb2.in.unknown2 = IVAL(req->in.body, 0x04);
196 io->smb2.in.unknown3 = IVAL(req->in.body, 0x08);
197 SMB2SRV_CHECK(smb2_pull_o16s16_blob(&req->in, io, req->in.body+0x0C, &io->smb2.in.secblob));
198 io->smb2.in.unknown4 = BVAL(req->in.body, 0x10);
200 smb2srv_sesssetup_backend(req, io);
203 static NTSTATUS smb2srv_logoff_backend(struct smb2srv_request *req)
205 /* TODO: call ntvfs backends to close file of this session */
206 talloc_free(req->session);
211 static void smb2srv_logoff_send(struct smb2srv_request *req)
213 if (NT_STATUS_IS_ERR(req->status)) {
214 smb2srv_send_error(req, req->status);
218 SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x04, False, 0));
220 SSVAL(req->out.body, 0x02, 0);
222 smb2srv_send_reply(req);
225 void smb2srv_logoff_recv(struct smb2srv_request *req)
229 SMB2SRV_CHECK_BODY_SIZE(req, 0x04, False);
231 _pad = SVAL(req->in.body, 0x02);
233 req->status = smb2srv_logoff_backend(req);
235 if (req->control_flags & SMB2SRV_REQ_CTRL_FLAG_NOT_REPLY) {
239 smb2srv_logoff_send(req);