sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-02 09:47:23 +03:00
Code

converted the out side of SMB2 negprot handling

Browse Source 
This follows the SMB2 PFIF docs. Current versions of Vista can now connect to Samba4 as a SMB2 server
and do basic operations
(This used to be commit 9dc284770df9393a1a619735dc7a148713936fa7)
This commit is contained in:
Andrew Tridgell 2008-02-12 16:20:13 +11:00
parent 7b96c53bcb
commit 8fdb9504dc
4 changed files with 66 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
source4/libcli/raw/rawnegotiate.c
View File

@ -40,6 +40,10 @@ static const struct {
{PROTOCOL_LANMAN2,"Samba"},
{PROTOCOL_NT1,"NT LANMAN 1.0"},
{PROTOCOL_NT1,"NT LM 0.12"},
#if 0
/* we don't yet handle chaining a SMB transport onto SMB2 */
{PROTOCOL_SMB2,"SMB 2.002"},
#endif
};
/*

43
source4/libcli/smb2/negprot.c
View File

@ -32,7 +32,6 @@ struct smb2_request *smb2_negprot_send(struct smb2_transport *transport,
{
struct smb2_request *req;
uint16_t size = 0x24 + io->in.dialect_count*2;
DATA_BLOB guid_blob;
enum ndr_err_code ndr_err;
int i;
@ -40,20 +39,16 @@ struct smb2_request *smb2_negprot_send(struct smb2_transport *transport,
if (req == NULL) return NULL;
ndr_err = ndr_push_struct_blob(&guid_blob, req, NULL,
&io->in.client_guid,
(ndr_push_flags_fn_t)ndr_push_GUID);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err) || guid_blob.length != 16) {
talloc_free(req);
return NULL;
}
SSVAL(req->out.body, 0x00, 0x24);
SSVAL(req->out.body, 0x02, io->in.dialect_count);
SSVAL(req->out.body, 0x04, io->in.security_mode);
SSVAL(req->out.body, 0x06, io->in.reserved);
SIVAL(req->out.body, 0x08, io->in.capabilities);
memcpy(req->out.body+0x0C, guid_blob.data, guid_blob.length);
ndr_err = smbcli_push_guid(req->out.body, 0x0C, &io->in.client_guid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
talloc_free(req);
return NULL;
}
smbcli_push_nttime(req->out.body, 0x1C, io->in.start_time);
for (i=0;i<io->in.dialect_count;i++) {
SSVAL(req->out.body, 0x24 + i*2, io->in.dialects[i]);
@ -71,6 +66,7 @@ NTSTATUS smb2_negprot_recv(struct smb2_request *req, TALLOC_CTX *mem_ctx,
struct smb2_negprot *io)
{
NTSTATUS status;
enum ndr_err_code ndr_err;
if (!smb2_request_receive(req) ||
smb2_request_is_error(req)) {
@ -79,24 +75,27 @@ NTSTATUS smb2_negprot_recv(struct smb2_request *req, TALLOC_CTX *mem_ctx,
SMB2_CHECK_PACKET_RECV(req, 0x40, true);
io->out._pad = SVAL(req->in.body, 0x02);
io->out.unknown2 = IVAL(req->in.body, 0x04);
memcpy(io->out.sessid, req->in.body + 0x08, 16);
io->out.unknown3 = IVAL(req->in.body, 0x18);
io->out.unknown4 = SVAL(req->in.body, 0x1C);
io->out.unknown5 = IVAL(req->in.body, 0x1E);
io->out.unknown6 = IVAL(req->in.body, 0x22);
io->out.unknown7 = SVAL(req->in.body, 0x26);
io->out.current_time = smbcli_pull_nttime(req->in.body, 0x28);
io->out.boot_time = smbcli_pull_nttime(req->in.body, 0x30);
io->out.security_mode = SVAL(req->in.body, 0x02);
io->out.dialect_revision = SVAL(req->in.body, 0x04);
io->out.reserved = SVAL(req->in.body, 0x06);
ndr_err = smbcli_pull_guid(req->in.body, 0x08, &io->in.client_guid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
smb2_request_destroy(req);
return NT_STATUS_INTERNAL_ERROR;
}
io->out.capabilities = IVAL(req->in.body, 0x18);
io->out.max_transact_size = IVAL(req->in.body, 0x1C);
io->out.max_read_size = IVAL(req->in.body, 0x20);
io->out.max_write_size = IVAL(req->in.body, 0x24);
io->out.system_time = smbcli_pull_nttime(req->in.body, 0x28);
io->out.server_start_time = smbcli_pull_nttime(req->in.body, 0x30);
io->out.reserved2 = IVAL(req->in.body, 0x3C);
status = smb2_pull_o16s16_blob(&req->in, mem_ctx, req->in.body+0x38, &io->out.secblob);
if (!NT_STATUS_IS_OK(status)) {
smb2_request_destroy(req);
return status;
}
io->out.unknown9 = IVAL(req->in.body, 0x3C);
return smb2_request_destroy(req);
}

24
source4/libcli/smb2/smb2_calls.h
View File

@ -35,21 +35,19 @@ struct smb2_negprot {
struct {
/* static body buffer 64 (0x40) bytes */
/* uint16_t buffer_code; 0x41 = 0x40 + 1 */
uint16_t _pad;
uint32_t unknown2; /* 0x06 */
uint8_t sessid[16];
uint32_t unknown3; /* 0x0d */
uint16_t unknown4; /* 0x00 */
uint32_t unknown5; /* 0x01 */
uint32_t unknown6; /* 0x01 */
uint16_t unknown7; /* 0x01 */
NTTIME current_time;
NTTIME boot_time;
uint16_t security_mode;
uint16_t dialect_revision;
uint16_t reserved;
struct GUID server_guid;
uint32_t capabilities;
uint32_t max_transact_size;
uint32_t max_read_size;
uint32_t max_write_size;
NTTIME system_time;
NTTIME server_start_time;
/* uint16_t secblob_ofs */
/* uint16_t secblob_size */
uint32_t unknown9; /* 0x204d4c20 */
/* dynamic body buffer */
uint32_t reserved2;
DATA_BLOB secblob;
} out;
};

59
source4/smb_server/smb2/negprot.c
View File

@ -96,7 +96,7 @@ static NTSTATUS smb2srv_negprot_backend(struct smb2srv_request *req, struct smb2
/* we only do dialect 0 for now */
if (io->in.dialect_count < 1 ||
io->in.dialects[0] != 0) {
return NT_STATUS_NOT_SUPPORTED;
DEBUG(0,("Got unexpected SMB2 dialect %u\n", io->in.dialects[0]));
}
req->smb_conn->negotiate.protocol = PROTOCOL_SMB2;
@ -104,19 +104,19 @@ static NTSTATUS smb2srv_negprot_backend(struct smb2srv_request *req, struct smb2
current_time = timeval_current(); /* TODO: handle timezone?! */
boot_time = timeval_current(); /* TODO: fix me */
io->out._pad = 0;
io->out.unknown2 = 0x06;
ZERO_STRUCT(io->out.sessid);
io->out.unknown3 = 0x0d;
io->out.unknown4 = 0x00;
io->out.unknown5 = 0x01;
io->out.unknown6 = 0x01;
io->out.unknown7 = 0x01;
io->out.current_time = timeval_to_nttime(&current_time);
io->out.boot_time = timeval_to_nttime(&boot_time);
ZERO_STRUCT(io->out);
io->out.security_mode = 0; /* no signing yet */
/* choose the first dialect offered for now */
io->out.dialect_revision = io->in.dialects[0];
io->out.capabilities = 0;
io->out.max_transact_size = 0x10000;
io->out.max_read_size = 0x10000;
io->out.max_write_size = 0x10000;
io->out.system_time = timeval_to_nttime(&current_time);
io->out.server_start_time = timeval_to_nttime(&boot_time);
io->out.reserved2 = 0;
status = smb2srv_negprot_secblob(req, &io->out.secblob);
NT_STATUS_NOT_OK_RETURN(status);
io->out.unknown9 = 0x204d4c20;
return NT_STATUS_OK;
}
@ -124,6 +124,7 @@ static NTSTATUS smb2srv_negprot_backend(struct smb2srv_request *req, struct smb2
static void smb2srv_negprot_send(struct smb2srv_request *req, struct smb2_negprot *io)
{
NTSTATUS status;
enum ndr_err_code ndr_err;
if (NT_STATUS_IS_ERR(req->status)) {
smb2srv_send_error(req, req->status); /* TODO: is this correct? */
@ -137,16 +138,22 @@ static void smb2srv_negprot_send(struct smb2srv_request *req, struct smb2_negpro
return;
}
SSVAL(req->out.body, 0x02, io->out._pad);
SIVAL(req->out.body, 0x04, io->out.unknown2);
memcpy(req->out.body+0x08, io->out.sessid, 16);
SIVAL(req->out.body, 0x18, io->out.unknown3);
SSVAL(req->out.body, 0x1C, io->out.unknown4);
SIVAL(req->out.body, 0x1E, io->out.unknown5);
SIVAL(req->out.body, 0x22, io->out.unknown6);
SSVAL(req->out.body, 0x26, io->out.unknown7);
push_nttime(req->out.body, 0x28, io->out.current_time);
push_nttime(req->out.body, 0x30, io->out.boot_time);
SSVAL(req->out.body, 0x02, io->out.security_mode);
SIVAL(req->out.body, 0x04, io->out.dialect_revision);
SIVAL(req->out.body, 0x06, io->out.reserved);
ndr_err = smbcli_push_guid(req->out.body, 0x08, &io->out.server_guid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
smbsrv_terminate_connection(req->smb_conn, nt_errstr(status));
talloc_free(req);
return;
}
SIVAL(req->out.body, 0x18, io->out.capabilities);
SIVAL(req->out.body, 0x1C, io->out.max_transact_size);
SIVAL(req->out.body, 0x20, io->out.max_read_size);
SIVAL(req->out.body, 0x24, io->out.max_write_size);
push_nttime(req->out.body, 0x28, io->out.system_time);
push_nttime(req->out.body, 0x30, io->out.server_start_time);
SIVAL(req->out.body, 0x3C, io->out.reserved2);
status = smb2_push_o16s16_blob(&req->out, 0x38, io->out.secblob);
if (!NT_STATUS_IS_OK(status)) {
smbsrv_terminate_connection(req->smb_conn, nt_errstr(status));
@ -154,8 +161,6 @@ static void smb2srv_negprot_send(struct smb2srv_request *req, struct smb2_negpro
return;
}
SIVAL(req->out.body, 0x3C, io->out.unknown9);
smb2srv_send_reply(req);
}
@ -163,7 +168,6 @@ void smb2srv_negprot_recv(struct smb2srv_request *req)
{
struct smb2_negprot *io;
int i;
DATA_BLOB guid_blob;
enum ndr_err_code ndr_err;
if (req->in.body_size < 0x26) {
@ -182,10 +186,7 @@ void smb2srv_negprot_recv(struct smb2srv_request *req)
io->in.security_mode = SVAL(req->in.body, 0x04);
io->in.reserved = SVAL(req->in.body, 0x06);
io->in.capabilities = IVAL(req->in.body, 0x08);
guid_blob.data = req->in.body + 0xC;
guid_blob.length = 16;
ndr_err = ndr_pull_struct_blob(&guid_blob, req, NULL, &io->in.client_guid,
(ndr_pull_flags_fn_t)ndr_pull_GUID);
ndr_err = smbcli_pull_guid(req->in.body, 0xC, &io->in.client_guid);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
smbsrv_terminate_connection(req->smb_conn, nt_errstr(NT_STATUS_FOOBAR));
talloc_free(req);