source: vendor/current/source4/libcli/raw/clisocket.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 11.7 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3
4 SMB client socket 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 "system/network.h"
25#include "../lib/async_req/async_sock.h"
26#include "../lib/util/tevent_ntstatus.h"
27#include "lib/events/events.h"
28#include "libcli/raw/libcliraw.h"
29#include "libcli/composite/composite.h"
30#include "lib/socket/socket.h"
31#include "libcli/resolve/resolve.h"
32#include "param/param.h"
33#include "libcli/raw/raw_proto.h"
34#include "../libcli/smb/read_smb.h"
35
36struct smbcli_transport_connect_state {
37 struct tevent_context *ev;
38 struct socket_context *sock;
39 struct tevent_req *io_req;
40 uint8_t *request;
41 struct iovec iov;
42 uint8_t *response;
43};
44
45static void smbcli_transport_connect_cleanup(struct tevent_req *req,
46 enum tevent_req_state req_state);
47static void smbcli_transport_connect_writev_done(struct tevent_req *subreq);
48static void smbcli_transport_connect_read_smb_done(struct tevent_req *subreq);
49
50static struct tevent_req *smbcli_transport_connect_send(TALLOC_CTX *mem_ctx,
51 struct tevent_context *ev,
52 struct socket_context *sock,
53 uint16_t port,
54 uint32_t timeout_msec,
55 struct nbt_name *calling,
56 struct nbt_name *called)
57{
58 struct tevent_req *req;
59 struct smbcli_transport_connect_state *state;
60 struct tevent_req *subreq;
61 DATA_BLOB calling_blob, called_blob;
62 uint8_t *p;
63 NTSTATUS status;
64
65 req = tevent_req_create(mem_ctx, &state,
66 struct smbcli_transport_connect_state);
67 if (req == NULL) {
68 return NULL;
69 }
70 state->ev = ev;
71 state->sock = sock;
72
73 if (port != 139) {
74 tevent_req_done(req);
75 return tevent_req_post(req, ev);
76 }
77
78 tevent_req_set_cleanup_fn(req, smbcli_transport_connect_cleanup);
79
80 status = nbt_name_to_blob(state, &calling_blob, calling);
81 if (tevent_req_nterror(req, status)) {
82 return tevent_req_post(req, ev);
83 }
84
85 status = nbt_name_to_blob(state, &called_blob, called);
86 if (tevent_req_nterror(req, status)) {
87 return tevent_req_post(req, ev);
88 }
89
90 state->request = talloc_array(state, uint8_t,
91 NBT_HDR_SIZE +
92 called_blob.length +
93 calling_blob.length);
94 if (tevent_req_nomem(state->request, req)) {
95 return tevent_req_post(req, ev);
96 }
97
98 /* put in the destination name */
99 p = state->request + NBT_HDR_SIZE;
100 memcpy(p, called_blob.data, called_blob.length);
101 p += called_blob.length;
102
103 memcpy(p, calling_blob.data, calling_blob.length);
104 p += calling_blob.length;
105
106 _smb_setlen_nbt(state->request,
107 PTR_DIFF(p, state->request) - NBT_HDR_SIZE);
108 SCVAL(state->request, 0, NBSSrequest);
109
110 state->iov.iov_len = talloc_array_length(state->request);
111 state->iov.iov_base = (void *)state->request;
112
113 subreq = writev_send(state, ev, NULL,
114 sock->fd,
115 true, /* err_on_readability */
116 &state->iov, 1);
117 if (tevent_req_nomem(subreq, req)) {
118 return tevent_req_post(req, ev);
119 }
120 tevent_req_set_callback(subreq,
121 smbcli_transport_connect_writev_done,
122 req);
123 state->io_req = subreq;
124
125 if (timeout_msec > 0) {
126 struct timeval endtime;
127
128 endtime = timeval_current_ofs_msec(timeout_msec);
129 if (!tevent_req_set_endtime(req, ev, endtime)) {
130 return tevent_req_post(req, ev);
131 }
132 }
133
134 return req;
135}
136
137static void smbcli_transport_connect_cleanup(struct tevent_req *req,
138 enum tevent_req_state req_state)
139{
140 struct smbcli_transport_connect_state *state =
141 tevent_req_data(req,
142 struct smbcli_transport_connect_state);
143
144 TALLOC_FREE(state->io_req);
145
146 if (state->sock == NULL) {
147 return;
148 }
149
150 if (state->sock->fd == -1) {
151 return;
152 }
153
154 if (req_state == TEVENT_REQ_DONE) {
155 /*
156 * we keep the socket open for the caller to use
157 */
158 state->sock = NULL;
159 return;
160 }
161
162 close(state->sock->fd);
163 state->sock->fd = -1;
164 state->sock = NULL;
165}
166
167static void smbcli_transport_connect_writev_done(struct tevent_req *subreq)
168{
169 struct tevent_req *req =
170 tevent_req_callback_data(subreq,
171 struct tevent_req);
172 struct smbcli_transport_connect_state *state =
173 tevent_req_data(req,
174 struct smbcli_transport_connect_state);
175 ssize_t ret;
176 int err;
177
178 state->io_req = NULL;
179
180 ret = writev_recv(subreq, &err);
181 TALLOC_FREE(subreq);
182 if (ret == -1) {
183 NTSTATUS status = map_nt_error_from_unix_common(err);
184 tevent_req_nterror(req, status);
185 return;
186 }
187
188 subreq = read_smb_send(state, state->ev,
189 state->sock->fd);
190 if (tevent_req_nomem(subreq, req)) {
191 return;
192 }
193 tevent_req_set_callback(subreq,
194 smbcli_transport_connect_read_smb_done,
195 req);
196 state->io_req = subreq;
197}
198
199static void smbcli_transport_connect_read_smb_done(struct tevent_req *subreq)
200{
201 struct tevent_req *req =
202 tevent_req_callback_data(subreq,
203 struct tevent_req);
204 struct smbcli_transport_connect_state *state =
205 tevent_req_data(req,
206 struct smbcli_transport_connect_state);
207 ssize_t ret;
208 int err;
209 NTSTATUS status;
210 uint8_t error;
211
212 state->io_req = NULL;
213
214 ret = read_smb_recv(subreq, state,
215 &state->response, &err);
216 TALLOC_FREE(subreq);
217 if (ret == -1) {
218 status = map_nt_error_from_unix_common(err);
219 tevent_req_nterror(req, status);
220 return;
221 }
222
223 if (ret < 4) {
224 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
225 return;
226 }
227
228 switch (CVAL(state->response, 0)) {
229 case NBSSpositive:
230 tevent_req_done(req);
231 return;
232
233 case NBSSnegative:
234 if (ret < 5) {
235 tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
236 return;
237 }
238
239 error = CVAL(state->response, 4);
240 switch (error) {
241 case 0x80:
242 case 0x81:
243 status = NT_STATUS_REMOTE_NOT_LISTENING;
244 break;
245 case 0x82:
246 status = NT_STATUS_RESOURCE_NAME_NOT_FOUND;
247 break;
248 case 0x83:
249 status = NT_STATUS_REMOTE_RESOURCES;
250 break;
251 default:
252 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
253 break;
254 }
255 break;
256
257 case NBSSretarget:
258 DEBUG(1,("Warning: session retarget not supported\n"));
259 status = NT_STATUS_NOT_SUPPORTED;
260 break;
261
262 default:
263 status = NT_STATUS_INVALID_NETWORK_RESPONSE;
264 break;
265 }
266
267 tevent_req_nterror(req, status);
268}
269
270static NTSTATUS smbcli_transport_connect_recv(struct tevent_req *req)
271{
272 return tevent_req_simple_recv_ntstatus(req);
273}
274
275struct sock_connect_state {
276 struct composite_context *ctx;
277 const char *host_name;
278 int num_ports;
279 uint16_t *ports;
280 const char *socket_options;
281 struct smbcli_socket *result;
282 struct socket_connect_multi_ex multi_ex;
283 struct nbt_name calling;
284 struct nbt_name called;
285};
286
287/*
288 connect a smbcli_socket context to an IP/port pair
289 if port is 0 then choose 445 then 139
290*/
291
292static struct tevent_req *smbcli_sock_establish_send(TALLOC_CTX *mem_ctx,
293 struct tevent_context *ev,
294 struct socket_context *sock,
295 struct socket_address *addr,
296 void *private_data)
297{
298 struct sock_connect_state *state =
299 talloc_get_type_abort(private_data,
300 struct sock_connect_state);
301 uint32_t timeout_msec = 15 * 1000;
302
303 return smbcli_transport_connect_send(state,
304 ev,
305 sock,
306 addr->port,
307 timeout_msec,
308 &state->calling,
309 &state->called);
310}
311
312static NTSTATUS smbcli_sock_establish_recv(struct tevent_req *req)
313{
314 return smbcli_transport_connect_recv(req);
315}
316
317static void smbcli_sock_connect_recv_conn(struct composite_context *ctx);
318
319struct composite_context *smbcli_sock_connect_send(TALLOC_CTX *mem_ctx,
320 const char *host_addr,
321 const char **ports,
322 const char *host_name,
323 struct resolve_context *resolve_ctx,
324 struct tevent_context *event_ctx,
325 const char *socket_options,
326 struct nbt_name *calling,
327 struct nbt_name *called)
328{
329 struct composite_context *result, *ctx;
330 struct sock_connect_state *state;
331 NTSTATUS status;
332 int i;
333
334 result = talloc_zero(mem_ctx, struct composite_context);
335 if (result == NULL) goto failed;
336 result->state = COMPOSITE_STATE_IN_PROGRESS;
337
338 result->event_ctx = event_ctx;
339 if (result->event_ctx == NULL) goto failed;
340
341 state = talloc(result, struct sock_connect_state);
342 if (state == NULL) goto failed;
343 state->ctx = result;
344 result->private_data = state;
345
346 state->host_name = talloc_strdup(state, host_name);
347 if (state->host_name == NULL) goto failed;
348
349 state->num_ports = str_list_length(ports);
350 state->ports = talloc_array(state, uint16_t, state->num_ports);
351 if (state->ports == NULL) goto failed;
352 for (i=0;ports[i];i++) {
353 state->ports[i] = atoi(ports[i]);
354 }
355 state->socket_options = talloc_reference(state, socket_options);
356
357 if (!host_addr) {
358 host_addr = host_name;
359 }
360
361 state->multi_ex.private_data = state;
362 state->multi_ex.establish_send = smbcli_sock_establish_send;
363 state->multi_ex.establish_recv = smbcli_sock_establish_recv;
364
365 status = nbt_name_dup(state, calling, &state->calling);
366 if (!NT_STATUS_IS_OK(status)) {
367 goto failed;
368 }
369 status = nbt_name_dup(state, called, &state->called);
370 if (!NT_STATUS_IS_OK(status)) {
371 goto failed;
372 }
373
374 ctx = socket_connect_multi_ex_send(state, host_addr,
375 state->num_ports, state->ports,
376 resolve_ctx,
377 state->ctx->event_ctx,
378 &state->multi_ex);
379 if (ctx == NULL) goto failed;
380 ctx->async.fn = smbcli_sock_connect_recv_conn;
381 ctx->async.private_data = state;
382 return result;
383
384failed:
385 talloc_free(result);
386 return NULL;
387}
388
389static void smbcli_sock_connect_recv_conn(struct composite_context *ctx)
390{
391 struct sock_connect_state *state =
392 talloc_get_type(ctx->async.private_data,
393 struct sock_connect_state);
394 struct socket_context *sock;
395 uint16_t port;
396
397 state->ctx->status = socket_connect_multi_ex_recv(ctx, state, &sock,
398 &port);
399 if (!composite_is_ok(state->ctx)) return;
400
401 state->ctx->status =
402 socket_set_option(sock, state->socket_options, NULL);
403 if (!composite_is_ok(state->ctx)) return;
404
405
406 state->result = talloc_zero(state, struct smbcli_socket);
407 if (composite_nomem(state->result, state->ctx)) return;
408
409 state->result->sock = talloc_steal(state->result, sock);
410 state->result->port = port;
411 state->result->hostname = talloc_steal(sock, state->host_name);
412
413 state->result->event.ctx = state->ctx->event_ctx;
414 if (composite_nomem(state->result->event.ctx, state->ctx)) return;
415
416 composite_done(state->ctx);
417}
418
419/*
420 finish a smbcli_sock_connect_send() operation
421*/
422NTSTATUS smbcli_sock_connect_recv(struct composite_context *c,
423 TALLOC_CTX *mem_ctx,
424 struct smbcli_socket **result)
425{
426 NTSTATUS status = composite_wait(c);
427 if (NT_STATUS_IS_OK(status)) {
428 struct sock_connect_state *state =
429 talloc_get_type(c->private_data,
430 struct sock_connect_state);
431 *result = talloc_steal(mem_ctx, state->result);
432 }
433 talloc_free(c);
434 return status;
435}
436
437/*
438 connect a smbcli_socket context to an IP/port pair
439 if port is 0 then choose the ports listed in smb.conf (normally 445 then 139)
440
441 sync version of the function
442*/
443NTSTATUS smbcli_sock_connect(TALLOC_CTX *mem_ctx,
444 const char *host_addr, const char **ports,
445 const char *host_name,
446 struct resolve_context *resolve_ctx,
447 struct tevent_context *event_ctx,
448 const char *socket_options,
449 struct nbt_name *calling,
450 struct nbt_name *called,
451 struct smbcli_socket **result)
452{
453 struct composite_context *c =
454 smbcli_sock_connect_send(mem_ctx, host_addr, ports, host_name,
455 resolve_ctx,
456 event_ctx, socket_options,
457 calling, called);
458 return smbcli_sock_connect_recv(c, mem_ctx, result);
459}
Note: See TracBrowser for help on using the repository browser.