librpc: Shorten dcerpc_binding_handle_call a bit
[Samba/gebeck_regimport.git] / source3 / libsmb / smbsock_connect.c
blob403750d7192c2a9f723871376d7aaebf35f5fd24
1 /*
2 Unix SMB/CIFS implementation.
3 Connect to 445 and 139/nbsesssetup
4 Copyright (C) Volker Lendecke 2010
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.
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.
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/>.
20 #include "includes.h"
21 #include "../lib/async_req/async_sock.h"
22 #include "../lib/util/tevent_ntstatus.h"
23 #include "../lib/util/tevent_unix.h"
24 #include "client.h"
25 #include "async_smb.h"
26 #include "../libcli/smb/read_smb.h"
27 #include "libsmb/nmblib.h"
29 struct cli_session_request_state {
30 struct tevent_context *ev;
31 int sock;
32 uint32 len_hdr;
33 struct iovec iov[3];
34 uint8_t nb_session_response;
37 static void cli_session_request_sent(struct tevent_req *subreq);
38 static void cli_session_request_recvd(struct tevent_req *subreq);
40 static struct tevent_req *cli_session_request_send(TALLOC_CTX *mem_ctx,
41 struct tevent_context *ev,
42 int sock,
43 const struct nmb_name *called,
44 const struct nmb_name *calling)
46 struct tevent_req *req, *subreq;
47 struct cli_session_request_state *state;
49 req = tevent_req_create(mem_ctx, &state,
50 struct cli_session_request_state);
51 if (req == NULL) {
52 return NULL;
54 state->ev = ev;
55 state->sock = sock;
57 state->iov[1].iov_base = name_mangle(
58 state, called->name, called->name_type);
59 if (tevent_req_nomem(state->iov[1].iov_base, req)) {
60 return tevent_req_post(req, ev);
62 state->iov[1].iov_len = name_len(
63 (unsigned char *)state->iov[1].iov_base,
64 talloc_get_size(state->iov[1].iov_base));
66 state->iov[2].iov_base = name_mangle(
67 state, calling->name, calling->name_type);
68 if (tevent_req_nomem(state->iov[2].iov_base, req)) {
69 return tevent_req_post(req, ev);
71 state->iov[2].iov_len = name_len(
72 (unsigned char *)state->iov[2].iov_base,
73 talloc_get_size(state->iov[2].iov_base));
75 _smb_setlen(((char *)&state->len_hdr),
76 state->iov[1].iov_len + state->iov[2].iov_len);
77 SCVAL((char *)&state->len_hdr, 0, 0x81);
79 state->iov[0].iov_base = &state->len_hdr;
80 state->iov[0].iov_len = sizeof(state->len_hdr);
82 subreq = writev_send(state, ev, NULL, sock, true, state->iov, 3);
83 if (tevent_req_nomem(subreq, req)) {
84 return tevent_req_post(req, ev);
86 tevent_req_set_callback(subreq, cli_session_request_sent, req);
87 return req;
90 static void cli_session_request_sent(struct tevent_req *subreq)
92 struct tevent_req *req = tevent_req_callback_data(
93 subreq, struct tevent_req);
94 struct cli_session_request_state *state = tevent_req_data(
95 req, struct cli_session_request_state);
96 ssize_t ret;
97 int err;
99 ret = writev_recv(subreq, &err);
100 TALLOC_FREE(subreq);
101 if (ret == -1) {
102 tevent_req_error(req, err);
103 return;
105 subreq = read_smb_send(state, state->ev, state->sock);
106 if (tevent_req_nomem(subreq, req)) {
107 return;
109 tevent_req_set_callback(subreq, cli_session_request_recvd, req);
112 static void cli_session_request_recvd(struct tevent_req *subreq)
114 struct tevent_req *req = tevent_req_callback_data(
115 subreq, struct tevent_req);
116 struct cli_session_request_state *state = tevent_req_data(
117 req, struct cli_session_request_state);
118 uint8_t *buf;
119 ssize_t ret;
120 int err;
122 ret = read_smb_recv(subreq, talloc_tos(), &buf, &err);
123 TALLOC_FREE(subreq);
125 if (ret < 4) {
126 ret = -1;
127 err = EIO;
129 if (ret == -1) {
130 tevent_req_error(req, err);
131 return;
134 * In case of an error there is more information in the data
135 * portion according to RFC1002. We're not subtle enough to
136 * respond to the different error conditions, so drop the
137 * error info here.
139 state->nb_session_response = CVAL(buf, 0);
140 tevent_req_done(req);
143 static bool cli_session_request_recv(struct tevent_req *req, int *err, uint8_t *resp)
145 struct cli_session_request_state *state = tevent_req_data(
146 req, struct cli_session_request_state);
148 if (tevent_req_is_unix_error(req, err)) {
149 return false;
151 *resp = state->nb_session_response;
152 return true;
155 struct nb_connect_state {
156 struct tevent_context *ev;
157 const struct sockaddr_storage *addr;
158 const char *called_name;
159 int sock;
161 struct nmb_name called;
162 struct nmb_name calling;
165 static int nb_connect_state_destructor(struct nb_connect_state *state);
166 static void nb_connect_connected(struct tevent_req *subreq);
167 static void nb_connect_done(struct tevent_req *subreq);
169 static struct tevent_req *nb_connect_send(TALLOC_CTX *mem_ctx,
170 struct tevent_context *ev,
171 const struct sockaddr_storage *addr,
172 const char *called_name,
173 int called_type,
174 const char *calling_name,
175 int calling_type)
177 struct tevent_req *req, *subreq;
178 struct nb_connect_state *state;
180 req = tevent_req_create(mem_ctx, &state, struct nb_connect_state);
181 if (req == NULL) {
182 return NULL;
184 state->ev = ev;
185 state->called_name = called_name;
186 state->addr = addr;
188 state->sock = -1;
189 make_nmb_name(&state->called, called_name, called_type);
190 make_nmb_name(&state->calling, calling_name, calling_type);
192 talloc_set_destructor(state, nb_connect_state_destructor);
194 subreq = open_socket_out_send(state, ev, addr, NBT_SMB_PORT, 5000);
195 if (tevent_req_nomem(subreq, req)) {
196 return tevent_req_post(req, ev);
198 tevent_req_set_callback(subreq, nb_connect_connected, req);
199 return req;
202 static int nb_connect_state_destructor(struct nb_connect_state *state)
204 if (state->sock != -1) {
205 close(state->sock);
207 return 0;
210 static void nb_connect_connected(struct tevent_req *subreq)
212 struct tevent_req *req = tevent_req_callback_data(
213 subreq, struct tevent_req);
214 struct nb_connect_state *state = tevent_req_data(
215 req, struct nb_connect_state);
216 NTSTATUS status;
218 status = open_socket_out_recv(subreq, &state->sock);
219 TALLOC_FREE(subreq);
220 if (!NT_STATUS_IS_OK(status)) {
221 tevent_req_nterror(req, status);
222 return;
224 subreq = cli_session_request_send(state, state->ev, state->sock,
225 &state->called, &state->calling);
226 if (tevent_req_nomem(subreq, req)) {
227 return;
229 tevent_req_set_callback(subreq, nb_connect_done, req);
232 static void nb_connect_done(struct tevent_req *subreq)
234 struct tevent_req *req = tevent_req_callback_data(
235 subreq, struct tevent_req);
236 struct nb_connect_state *state = tevent_req_data(
237 req, struct nb_connect_state);
238 bool ret;
239 int err;
240 uint8_t resp;
242 ret = cli_session_request_recv(subreq, &err, &resp);
243 TALLOC_FREE(subreq);
244 if (!ret) {
245 tevent_req_nterror(req, map_nt_error_from_unix(err));
246 return;
250 * RFC1002: 0x82 - POSITIVE SESSION RESPONSE
253 if (resp != 0x82) {
255 * The server did not like our session request
257 close(state->sock);
258 state->sock = -1;
260 if (strequal(state->called_name, "*SMBSERVER")) {
262 * Here we could try a name status request and
263 * use the first 0x20 type name.
265 tevent_req_nterror(
266 req, NT_STATUS_RESOURCE_NAME_NOT_FOUND);
267 return;
271 * We could be subtle and distinguish between
272 * different failure modes, but what we do here
273 * instead is just retry with *SMBSERVER type 0x20.
275 state->called_name = "*SMBSERVER";
276 make_nmb_name(&state->called, state->called_name, 0x20);
278 subreq = open_socket_out_send(state, state->ev, state->addr,
279 NBT_SMB_PORT, 5000);
280 if (tevent_req_nomem(subreq, req)) {
281 return;
283 tevent_req_set_callback(subreq, nb_connect_connected, req);
284 return;
287 tevent_req_done(req);
288 return;
292 static NTSTATUS nb_connect_recv(struct tevent_req *req, int *sock)
294 struct nb_connect_state *state = tevent_req_data(
295 req, struct nb_connect_state);
296 NTSTATUS status;
298 if (tevent_req_is_nterror(req, &status)) {
299 return status;
301 *sock = state->sock;
302 state->sock = -1;
303 return NT_STATUS_OK;
306 struct smbsock_connect_state {
307 struct tevent_context *ev;
308 const struct sockaddr_storage *addr;
309 const char *called_name;
310 uint8_t called_type;
311 const char *calling_name;
312 uint8_t calling_type;
313 struct tevent_req *req_139;
314 struct tevent_req *req_445;
315 int sock;
316 uint16_t port;
319 static int smbsock_connect_state_destructor(
320 struct smbsock_connect_state *state);
321 static void smbsock_connect_connected(struct tevent_req *subreq);
322 static void smbsock_connect_do_139(struct tevent_req *subreq);
324 struct tevent_req *smbsock_connect_send(TALLOC_CTX *mem_ctx,
325 struct tevent_context *ev,
326 const struct sockaddr_storage *addr,
327 uint16_t port,
328 const char *called_name,
329 int called_type,
330 const char *calling_name,
331 int calling_type)
333 struct tevent_req *req;
334 struct smbsock_connect_state *state;
336 req = tevent_req_create(mem_ctx, &state, struct smbsock_connect_state);
337 if (req == NULL) {
338 return NULL;
340 state->ev = ev;
341 state->addr = addr;
342 state->sock = -1;
343 state->called_name =
344 (called_name != NULL) ? called_name : "*SMBSERVER";
345 state->called_type =
346 (called_type != -1) ? called_type : 0x20;
347 state->calling_name =
348 (calling_name != NULL) ? calling_name : lp_netbios_name();
349 state->calling_type =
350 (calling_type != -1) ? calling_type : 0x00;
352 talloc_set_destructor(state, smbsock_connect_state_destructor);
354 if (port == NBT_SMB_PORT) {
355 state->req_139 = nb_connect_send(state, state->ev, state->addr,
356 state->called_name,
357 state->called_type,
358 state->calling_name,
359 state->calling_type);
360 if (tevent_req_nomem(state->req_139, req)) {
361 return tevent_req_post(req, ev);
363 tevent_req_set_callback(
364 state->req_139, smbsock_connect_connected, req);
365 return req;
367 if (port != 0) {
368 state->req_445 = open_socket_out_send(state, ev, addr, port,
369 5000);
370 if (tevent_req_nomem(state->req_445, req)) {
371 return tevent_req_post(req, ev);
373 tevent_req_set_callback(
374 state->req_445, smbsock_connect_connected, req);
375 return req;
379 * port==0, try both
382 state->req_445 = open_socket_out_send(state, ev, addr, TCP_SMB_PORT, 5000);
383 if (tevent_req_nomem(state->req_445, req)) {
384 return tevent_req_post(req, ev);
386 tevent_req_set_callback(state->req_445, smbsock_connect_connected,
387 req);
390 * After 5 msecs, fire the 139 (NBT) request
392 state->req_139 = tevent_wakeup_send(
393 state, ev, timeval_current_ofs(0, 5000));
394 if (tevent_req_nomem(state->req_139, req)) {
395 TALLOC_FREE(state->req_445);
396 return tevent_req_post(req, ev);
398 tevent_req_set_callback(state->req_139, smbsock_connect_do_139,
399 req);
400 return req;
403 static int smbsock_connect_state_destructor(
404 struct smbsock_connect_state *state)
406 if (state->sock != -1) {
407 close(state->sock);
408 state->sock = -1;
410 return 0;
413 static void smbsock_connect_do_139(struct tevent_req *subreq)
415 struct tevent_req *req = tevent_req_callback_data(
416 subreq, struct tevent_req);
417 struct smbsock_connect_state *state = tevent_req_data(
418 req, struct smbsock_connect_state);
419 bool ret;
421 ret = tevent_wakeup_recv(subreq);
422 TALLOC_FREE(subreq);
423 if (!ret) {
424 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
425 return;
427 state->req_139 = nb_connect_send(state, state->ev, state->addr,
428 state->called_name,
429 state->called_type,
430 state->calling_name,
431 state->calling_type);
432 if (tevent_req_nomem(state->req_139, req)) {
433 return;
435 tevent_req_set_callback(state->req_139, smbsock_connect_connected,
436 req);
439 static void smbsock_connect_connected(struct tevent_req *subreq)
441 struct tevent_req *req = tevent_req_callback_data(
442 subreq, struct tevent_req);
443 struct smbsock_connect_state *state = tevent_req_data(
444 req, struct smbsock_connect_state);
445 struct tevent_req *unfinished_req;
446 NTSTATUS status;
448 if (subreq == state->req_445) {
450 status = open_socket_out_recv(subreq, &state->sock);
451 TALLOC_FREE(state->req_445);
452 unfinished_req = state->req_139;
453 state->port = TCP_SMB_PORT;
455 } else if (subreq == state->req_139) {
457 status = nb_connect_recv(subreq, &state->sock);
458 TALLOC_FREE(state->req_139);
459 unfinished_req = state->req_445;
460 state->port = NBT_SMB_PORT;
462 } else {
463 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
464 return;
467 if (NT_STATUS_IS_OK(status)) {
468 TALLOC_FREE(unfinished_req);
469 state->req_139 = NULL;
470 state->req_445 = NULL;
471 tevent_req_done(req);
472 return;
474 if (unfinished_req == NULL) {
476 * Both requests failed
478 tevent_req_nterror(req, status);
479 return;
482 * Do nothing, wait for the second request to come here.
486 NTSTATUS smbsock_connect_recv(struct tevent_req *req, int *sock,
487 uint16_t *ret_port)
489 struct smbsock_connect_state *state = tevent_req_data(
490 req, struct smbsock_connect_state);
491 NTSTATUS status;
493 if (tevent_req_is_nterror(req, &status)) {
494 return status;
496 *sock = state->sock;
497 state->sock = -1;
498 if (ret_port != NULL) {
499 *ret_port = state->port;
501 return NT_STATUS_OK;
504 NTSTATUS smbsock_connect(const struct sockaddr_storage *addr, uint16_t port,
505 const char *called_name, int called_type,
506 const char *calling_name, int calling_type,
507 int *pfd, uint16_t *ret_port, int sec_timeout)
509 TALLOC_CTX *frame = talloc_stackframe();
510 struct tevent_context *ev;
511 struct tevent_req *req;
512 NTSTATUS status = NT_STATUS_NO_MEMORY;
514 ev = samba_tevent_context_init(frame);
515 if (ev == NULL) {
516 goto fail;
518 req = smbsock_connect_send(frame, ev, addr, port,
519 called_name, called_type,
520 calling_name, calling_type);
521 if (req == NULL) {
522 goto fail;
524 if ((sec_timeout != 0) &&
525 !tevent_req_set_endtime(
526 req, ev, timeval_current_ofs(sec_timeout, 0))) {
527 goto fail;
529 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
530 goto fail;
532 status = smbsock_connect_recv(req, pfd, ret_port);
533 fail:
534 TALLOC_FREE(frame);
535 return status;
538 struct smbsock_any_connect_state {
539 struct tevent_context *ev;
540 const struct sockaddr_storage *addrs;
541 const char **called_names;
542 int *called_types;
543 const char **calling_names;
544 int *calling_types;
545 size_t num_addrs;
546 uint16_t port;
548 struct tevent_req **requests;
549 size_t num_sent;
550 size_t num_received;
552 int fd;
553 uint16_t chosen_port;
554 size_t chosen_index;
557 static bool smbsock_any_connect_send_next(
558 struct tevent_req *req, struct smbsock_any_connect_state *state);
559 static void smbsock_any_connect_trynext(struct tevent_req *subreq);
560 static void smbsock_any_connect_connected(struct tevent_req *subreq);
562 struct tevent_req *smbsock_any_connect_send(TALLOC_CTX *mem_ctx,
563 struct tevent_context *ev,
564 const struct sockaddr_storage *addrs,
565 const char **called_names,
566 int *called_types,
567 const char **calling_names,
568 int *calling_types,
569 size_t num_addrs, uint16_t port)
571 struct tevent_req *req, *subreq;
572 struct smbsock_any_connect_state *state;
574 req = tevent_req_create(mem_ctx, &state,
575 struct smbsock_any_connect_state);
576 if (req == NULL) {
577 return NULL;
579 state->ev = ev;
580 state->addrs = addrs;
581 state->num_addrs = num_addrs;
582 state->called_names = called_names;
583 state->called_types = called_types;
584 state->calling_names = calling_names;
585 state->calling_types = calling_types;
586 state->port = port;
588 if (num_addrs == 0) {
589 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
590 return tevent_req_post(req, ev);
593 state->requests = talloc_zero_array(state, struct tevent_req *,
594 num_addrs);
595 if (tevent_req_nomem(state->requests, req)) {
596 return tevent_req_post(req, ev);
598 if (!smbsock_any_connect_send_next(req, state)) {
599 return tevent_req_post(req, ev);
601 if (state->num_sent >= state->num_addrs) {
602 return req;
604 subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(0, 10000));
605 if (tevent_req_nomem(subreq, req)) {
606 return tevent_req_post(req, ev);
608 tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
609 return req;
612 static void smbsock_any_connect_trynext(struct tevent_req *subreq)
614 struct tevent_req *req = tevent_req_callback_data(
615 subreq, struct tevent_req);
616 struct smbsock_any_connect_state *state = tevent_req_data(
617 req, struct smbsock_any_connect_state);
618 bool ret;
620 ret = tevent_wakeup_recv(subreq);
621 TALLOC_FREE(subreq);
622 if (!ret) {
623 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
624 return;
626 if (!smbsock_any_connect_send_next(req, state)) {
627 return;
629 if (state->num_sent >= state->num_addrs) {
630 return;
632 subreq = tevent_wakeup_send(state, state->ev,
633 tevent_timeval_set(0, 10000));
634 if (tevent_req_nomem(subreq, req)) {
635 return;
637 tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
640 static bool smbsock_any_connect_send_next(
641 struct tevent_req *req, struct smbsock_any_connect_state *state)
643 struct tevent_req *subreq;
645 if (state->num_sent >= state->num_addrs) {
646 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
647 return false;
649 subreq = smbsock_connect_send(
650 state->requests, state->ev, &state->addrs[state->num_sent],
651 state->port,
652 (state->called_names != NULL)
653 ? state->called_names[state->num_sent] : NULL,
654 (state->called_types != NULL)
655 ? state->called_types[state->num_sent] : -1,
656 (state->calling_names != NULL)
657 ? state->calling_names[state->num_sent] : NULL,
658 (state->calling_types != NULL)
659 ? state->calling_types[state->num_sent] : -1);
660 if (tevent_req_nomem(subreq, req)) {
661 return false;
663 tevent_req_set_callback(subreq, smbsock_any_connect_connected, req);
665 state->requests[state->num_sent] = subreq;
666 state->num_sent += 1;
668 return true;
671 static void smbsock_any_connect_connected(struct tevent_req *subreq)
673 struct tevent_req *req = tevent_req_callback_data(
674 subreq, struct tevent_req);
675 struct smbsock_any_connect_state *state = tevent_req_data(
676 req, struct smbsock_any_connect_state);
677 NTSTATUS status;
678 int fd;
679 uint16_t chosen_port;
680 size_t i;
681 size_t chosen_index = 0;
683 for (i=0; i<state->num_sent; i++) {
684 if (state->requests[i] == subreq) {
685 chosen_index = i;
686 break;
689 if (i == state->num_sent) {
690 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
691 return;
694 status = smbsock_connect_recv(subreq, &fd, &chosen_port);
696 TALLOC_FREE(subreq);
697 state->requests[chosen_index] = NULL;
699 if (NT_STATUS_IS_OK(status)) {
701 * This will kill all the other requests
703 TALLOC_FREE(state->requests);
704 state->fd = fd;
705 state->chosen_port = chosen_port;
706 state->chosen_index = chosen_index;
707 tevent_req_done(req);
708 return;
711 state->num_received += 1;
712 if (state->num_received < state->num_addrs) {
714 * More addrs pending, wait for the others
716 return;
720 * This is the last response, none succeeded.
722 tevent_req_nterror(req, status);
723 return;
726 NTSTATUS smbsock_any_connect_recv(struct tevent_req *req, int *pfd,
727 size_t *chosen_index,
728 uint16_t *chosen_port)
730 struct smbsock_any_connect_state *state = tevent_req_data(
731 req, struct smbsock_any_connect_state);
732 NTSTATUS status;
734 if (tevent_req_is_nterror(req, &status)) {
735 return status;
737 *pfd = state->fd;
738 if (chosen_index != NULL) {
739 *chosen_index = state->chosen_index;
741 if (chosen_port != NULL) {
742 *chosen_port = state->chosen_port;
744 return NT_STATUS_OK;
747 NTSTATUS smbsock_any_connect(const struct sockaddr_storage *addrs,
748 const char **called_names,
749 int *called_types,
750 const char **calling_names,
751 int *calling_types,
752 size_t num_addrs,
753 uint16_t port,
754 int sec_timeout,
755 int *pfd, size_t *chosen_index,
756 uint16_t *chosen_port)
758 TALLOC_CTX *frame = talloc_stackframe();
759 struct tevent_context *ev;
760 struct tevent_req *req;
761 NTSTATUS status = NT_STATUS_NO_MEMORY;
763 ev = samba_tevent_context_init(frame);
764 if (ev == NULL) {
765 goto fail;
767 req = smbsock_any_connect_send(frame, ev, addrs,
768 called_names, called_types,
769 calling_names, calling_types,
770 num_addrs, port);
771 if (req == NULL) {
772 goto fail;
774 if ((sec_timeout != 0) &&
775 !tevent_req_set_endtime(
776 req, ev, timeval_current_ofs(sec_timeout, 0))) {
777 goto fail;
779 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
780 goto fail;
782 status = smbsock_any_connect_recv(req, pfd, chosen_index, chosen_port);
783 fail:
784 TALLOC_FREE(frame);
785 return status;