Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : SMB client negotiate context management functions
5 :
6 : Copyright (C) Andrew Tridgell 1994-2005
7 : Copyright (C) James Myers 2003 <myersjj@samba.org>
8 :
9 : This program is free software; you can redistribute it and/or modify
10 : it under the terms of the GNU General Public License as published by
11 : the Free Software Foundation; either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : This program is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU General Public License for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "includes.h"
24 : #include <tevent.h>
25 : #include "system/time.h"
26 : #include "libcli/raw/libcliraw.h"
27 : #include "libcli/raw/raw_proto.h"
28 : #include "../libcli/smb/smbXcli_base.h"
29 : #include "../lib/util/tevent_ntstatus.h"
30 :
31 896 : NTSTATUS smb_raw_negotiate_fill_transport(struct smbcli_transport *transport)
32 : {
33 896 : struct smbcli_negotiate *n = &transport->negotiate;
34 896 : struct smbXcli_conn *c = transport->conn;
35 : NTTIME ntt;
36 :
37 896 : n->protocol = smbXcli_conn_protocol(c);
38 896 : if (n->protocol > PROTOCOL_NT1) {
39 0 : return NT_STATUS_REVISION_MISMATCH;
40 : }
41 :
42 896 : n->sec_mode = smb1cli_conn_server_security_mode(c);
43 896 : n->max_mux = smbXcli_conn_max_requests(c);
44 896 : n->max_xmit = smb1cli_conn_max_xmit(c);
45 896 : n->sesskey = smb1cli_conn_server_session_key(c);
46 896 : n->capabilities = smb1cli_conn_capabilities(c);;
47 :
48 : /* this time arrives in real GMT */
49 896 : ntt = smbXcli_conn_server_system_time(c);
50 896 : n->server_time = nt_time_to_unix(ntt);
51 896 : n->server_zone = smb1cli_conn_server_time_zone(c);
52 :
53 896 : if (n->capabilities & CAP_EXTENDED_SECURITY) {
54 888 : const DATA_BLOB *b = smbXcli_conn_server_gss_blob(c);
55 888 : if (b) {
56 888 : n->secblob = *b;
57 : }
58 : } else {
59 8 : const uint8_t *p = smb1cli_conn_server_challenge(c);
60 8 : if (p) {
61 8 : n->secblob = data_blob_const(p, 8);
62 : }
63 : }
64 :
65 896 : n->readbraw_supported = smb1cli_conn_server_readbraw(c);
66 896 : n->readbraw_supported = smb1cli_conn_server_writebraw(c);
67 896 : n->lockread_supported = smb1cli_conn_server_lockread(c);
68 :
69 896 : return NT_STATUS_OK;
70 : }
71 :
72 : struct smb_raw_negotiate_state {
73 : struct smbcli_transport *transport;
74 : };
75 :
76 : static void smb_raw_negotiate_done(struct tevent_req *subreq);
77 :
78 1124 : struct tevent_req *smb_raw_negotiate_send(TALLOC_CTX *mem_ctx,
79 : struct tevent_context *ev,
80 : struct smbcli_transport *transport,
81 : int minprotocol,
82 : int maxprotocol)
83 : {
84 : struct tevent_req *req;
85 : struct smb_raw_negotiate_state *state;
86 : struct tevent_req *subreq;
87 1124 : uint32_t timeout_msec = transport->options.request_timeout * 1000;
88 :
89 1124 : req = tevent_req_create(mem_ctx, &state,
90 : struct smb_raw_negotiate_state);;
91 1124 : if (req == NULL) {
92 0 : return NULL;
93 : }
94 1124 : state->transport = transport;
95 :
96 1124 : if (maxprotocol > PROTOCOL_NT1) {
97 0 : maxprotocol = PROTOCOL_NT1;
98 : }
99 :
100 1124 : if (minprotocol > maxprotocol) {
101 14 : minprotocol = maxprotocol;
102 : }
103 :
104 1124 : subreq = smbXcli_negprot_send(state, ev,
105 : transport->conn,
106 : timeout_msec,
107 : minprotocol,
108 : maxprotocol,
109 1124 : transport->options.max_credits,
110 : NULL);
111 1124 : if (tevent_req_nomem(subreq, req)) {
112 0 : return tevent_req_post(req, ev);
113 : }
114 1124 : tevent_req_set_callback(subreq, smb_raw_negotiate_done, req);
115 :
116 1124 : return req;
117 : }
118 :
119 1124 : static void smb_raw_negotiate_done(struct tevent_req *subreq)
120 : {
121 1066 : struct tevent_req *req =
122 1124 : tevent_req_callback_data(subreq,
123 : struct tevent_req);
124 1066 : struct smb_raw_negotiate_state *state =
125 1124 : tevent_req_data(req,
126 : struct smb_raw_negotiate_state);
127 : NTSTATUS status;
128 :
129 1124 : status = smbXcli_negprot_recv(subreq, NULL, NULL);
130 1124 : TALLOC_FREE(subreq);
131 1124 : if (tevent_req_nterror(req, status)) {
132 442 : return;
133 : }
134 :
135 896 : status = smb_raw_negotiate_fill_transport(state->transport);
136 896 : if (tevent_req_nterror(req, status)) {
137 0 : return;
138 : }
139 :
140 896 : tevent_req_done(req);
141 : }
142 :
143 : /*
144 : Send a negprot command.
145 : */
146 924 : NTSTATUS smb_raw_negotiate_recv(struct tevent_req *req)
147 : {
148 924 : return tevent_req_simple_recv_ntstatus(req);
149 : }
150 :
151 :
152 : /*
153 : Send a negprot command (sync interface)
154 : */
155 0 : NTSTATUS smb_raw_negotiate(struct smbcli_transport *transport, bool unicode,
156 : int minprotocol, int maxprotocol)
157 : {
158 : NTSTATUS status;
159 0 : struct tevent_req *subreq = NULL;
160 : bool ok;
161 :
162 0 : subreq = smb_raw_negotiate_send(transport,
163 : transport->ev,
164 : transport,
165 : minprotocol,
166 : maxprotocol);
167 0 : if (subreq == NULL) {
168 0 : status = NT_STATUS_NO_MEMORY;
169 0 : goto failed;
170 : }
171 :
172 0 : ok = tevent_req_poll(subreq, transport->ev);
173 0 : if (!ok) {
174 0 : status = map_nt_error_from_unix_common(errno);
175 0 : goto failed;
176 : }
177 :
178 0 : status = smb_raw_negotiate_recv(subreq);
179 :
180 0 : failed:
181 0 : TALLOC_FREE(subreq);
182 0 : return status;
183 : }
|
