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/>.
21 #include "../lib/async_req/async_sock.h"
22 #include "async_smb.h"
24 struct nb_connect_state {
25 struct tevent_context *ev;
26 const struct sockaddr_storage *addr;
27 const char *called_name;
30 struct nmb_name called;
31 struct nmb_name calling;
34 static int nb_connect_state_destructor(struct nb_connect_state *state);
35 static void nb_connect_connected(struct tevent_req *subreq);
36 static void nb_connect_done(struct tevent_req *subreq);
38 static struct tevent_req *nb_connect_send(TALLOC_CTX *mem_ctx,
39 struct tevent_context *ev,
40 const struct sockaddr_storage *addr,
41 const char *called_name,
43 const char *calling_name,
46 struct tevent_req *req, *subreq;
47 struct nb_connect_state *state;
49 req = tevent_req_create(mem_ctx, &state, struct nb_connect_state);
54 state->called_name = called_name;
58 make_nmb_name(&state->called, called_name, called_type);
59 make_nmb_name(&state->calling, calling_name, calling_type);
61 talloc_set_destructor(state, nb_connect_state_destructor);
63 subreq = open_socket_out_send(state, ev, addr, 139, 5000);
64 if (tevent_req_nomem(subreq, req)) {
65 return tevent_req_post(req, ev);
67 tevent_req_set_callback(subreq, nb_connect_connected, req);
71 static int nb_connect_state_destructor(struct nb_connect_state *state)
73 if (state->sock != -1) {
79 static void nb_connect_connected(struct tevent_req *subreq)
81 struct tevent_req *req = tevent_req_callback_data(
82 subreq, struct tevent_req);
83 struct nb_connect_state *state = tevent_req_data(
84 req, struct nb_connect_state);
87 status = open_socket_out_recv(subreq, &state->sock);
89 if (!NT_STATUS_IS_OK(status)) {
90 tevent_req_nterror(req, status);
93 subreq = cli_session_request_send(state, state->ev, state->sock,
94 &state->called, &state->calling);
95 if (tevent_req_nomem(subreq, req)) {
98 tevent_req_set_callback(subreq, nb_connect_done, req);
101 static void nb_connect_done(struct tevent_req *subreq)
103 struct tevent_req *req = tevent_req_callback_data(
104 subreq, struct tevent_req);
105 struct nb_connect_state *state = tevent_req_data(
106 req, struct nb_connect_state);
111 ret = cli_session_request_recv(subreq, &err, &resp);
114 tevent_req_nterror(req, map_nt_error_from_unix(err));
119 * RFC1002: 0x82 - POSITIVE SESSION RESPONSE
124 * The server did not like our session request
129 if (strequal(state->called_name, "*SMBSERVER")) {
131 * Here we could try a name status request and
132 * use the first 0x20 type name.
135 req, NT_STATUS_RESOURCE_NAME_NOT_FOUND);
140 * We could be subtle and distinguish between
141 * different failure modes, but what we do here
142 * instead is just retry with *SMBSERVER type 0x20.
144 state->called_name = "*SMBSERVER";
145 make_nmb_name(&state->called, state->called_name, 0x20);
147 subreq = open_socket_out_send(state, state->ev, state->addr,
149 if (tevent_req_nomem(subreq, req)) {
152 tevent_req_set_callback(subreq, nb_connect_connected, req);
156 tevent_req_done(req);
161 static NTSTATUS nb_connect_recv(struct tevent_req *req, int *sock)
163 struct nb_connect_state *state = tevent_req_data(
164 req, struct nb_connect_state);
167 if (tevent_req_is_nterror(req, &status)) {
175 struct smbsock_connect_state {
176 struct tevent_context *ev;
177 const struct sockaddr_storage *addr;
178 const char *called_name;
179 const char *calling_name;
180 struct tevent_req *req_139;
181 struct tevent_req *req_445;
186 static int smbsock_connect_state_destructor(
187 struct smbsock_connect_state *state);
188 static void smbsock_connect_connected(struct tevent_req *subreq);
189 static void smbsock_connect_do_139(struct tevent_req *subreq);
191 struct tevent_req *smbsock_connect_send(TALLOC_CTX *mem_ctx,
192 struct tevent_context *ev,
193 const struct sockaddr_storage *addr,
194 const char *called_name,
195 const char *calling_name)
197 struct tevent_req *req, *subreq;
198 struct smbsock_connect_state *state;
200 req = tevent_req_create(mem_ctx, &state, struct smbsock_connect_state);
208 (called_name != NULL) ? called_name : "*SMBSERVER";
209 state->calling_name =
210 (calling_name != NULL) ? calling_name : global_myname();
212 talloc_set_destructor(state, smbsock_connect_state_destructor);
214 state->req_445 = open_socket_out_send(state, ev, addr, 445, 5000);
215 if (tevent_req_nomem(state->req_445, req)) {
216 return tevent_req_post(req, ev);
218 tevent_req_set_callback(state->req_445, smbsock_connect_connected,
222 * After 5 msecs, fire the 139 request
224 state->req_139 = tevent_wakeup_send(
225 state, ev, timeval_current_ofs(0, 5000));
226 if (tevent_req_nomem(state->req_139, req)) {
227 TALLOC_FREE(state->req_445);
228 return tevent_req_post(req, ev);
230 tevent_req_set_callback(state->req_139, smbsock_connect_do_139,
235 static int smbsock_connect_state_destructor(
236 struct smbsock_connect_state *state)
238 if (state->sock != -1) {
244 static void smbsock_connect_do_139(struct tevent_req *subreq)
246 struct tevent_req *req = tevent_req_callback_data(
247 subreq, struct tevent_req);
248 struct smbsock_connect_state *state = tevent_req_data(
249 req, struct smbsock_connect_state);
252 ret = tevent_wakeup_recv(subreq);
255 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
258 state->req_139 = nb_connect_send(state, state->ev, state->addr,
259 state->called_name, 0x20,
260 state->calling_name, 0x0);
261 if (tevent_req_nomem(state->req_139, req)) {
264 tevent_req_set_callback(state->req_139, smbsock_connect_connected,
268 static void smbsock_connect_connected(struct tevent_req *subreq)
270 struct tevent_req *req = tevent_req_callback_data(
271 subreq, struct tevent_req);
272 struct smbsock_connect_state *state = tevent_req_data(
273 req, struct smbsock_connect_state);
274 struct tevent_req *unfinished_req;
277 if (subreq == state->req_445) {
279 status = open_socket_out_recv(subreq, &state->sock);
280 TALLOC_FREE(state->req_445);
281 unfinished_req = state->req_139;
284 } else if (subreq == state->req_139) {
286 status = nb_connect_recv(subreq, &state->sock);
287 TALLOC_FREE(state->req_139);
288 unfinished_req = state->req_445;
292 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
296 if (NT_STATUS_IS_OK(status)) {
297 TALLOC_FREE(unfinished_req);
298 state->req_139 = NULL;
299 state->req_445 = NULL;
300 tevent_req_done(req);
303 if (unfinished_req == NULL) {
305 * Both requests failed
307 tevent_req_nterror(req, status);
311 * Do nothing, wait for the second request to come here.
315 NTSTATUS smbsock_connect_recv(struct tevent_req *req, int *sock,
318 struct smbsock_connect_state *state = tevent_req_data(
319 req, struct smbsock_connect_state);
322 if (tevent_req_is_nterror(req, &status)) {
333 NTSTATUS smbsock_connect(const struct sockaddr_storage *addr,
334 const char *called_name, const char *calling_name,
335 int *pfd, uint16_t *port)
337 TALLOC_CTX *frame = talloc_stackframe();
338 struct event_context *ev;
339 struct tevent_req *req;
340 NTSTATUS status = NT_STATUS_NO_MEMORY;
342 ev = event_context_init(frame);
346 req = smbsock_connect_send(frame, ev, addr, called_name, calling_name);
350 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
353 status = smbsock_connect_recv(req, pfd, port);
359 struct smbsock_any_connect_state {
360 struct tevent_context *ev;
361 const struct sockaddr_storage *addrs;
362 const char **called_names;
365 struct tevent_req **requests;
374 static bool smbsock_any_connect_send_next(
375 struct tevent_req *req, struct smbsock_any_connect_state *state);
376 static void smbsock_any_connect_trynext(struct tevent_req *subreq);
377 static void smbsock_any_connect_connected(struct tevent_req *subreq);
379 struct tevent_req *smbsock_any_connect_send(TALLOC_CTX *mem_ctx,
380 struct tevent_context *ev,
381 const struct sockaddr_storage *addrs,
382 const char **called_names,
385 struct tevent_req *req, *subreq;
386 struct smbsock_any_connect_state *state;
388 req = tevent_req_create(mem_ctx, &state,
389 struct smbsock_any_connect_state);
394 state->addrs = addrs;
395 state->num_addrs = num_addrs;
396 state->called_names = called_names;
398 if (num_addrs == 0) {
399 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
400 return tevent_req_post(req, ev);
403 state->requests = talloc_zero_array(state, struct tevent_req *,
405 if (tevent_req_nomem(state->requests, req)) {
406 return tevent_req_post(req, ev);
408 if (!smbsock_any_connect_send_next(req, state)) {
409 return tevent_req_post(req, ev);
411 if (state->num_sent >= state->num_addrs) {
414 subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(0, 10000));
415 if (tevent_req_nomem(subreq, req)) {
416 return tevent_req_post(req, ev);
418 tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
422 static void smbsock_any_connect_trynext(struct tevent_req *subreq)
424 struct tevent_req *req = tevent_req_callback_data(
425 subreq, struct tevent_req);
426 struct smbsock_any_connect_state *state = tevent_req_data(
427 req, struct smbsock_any_connect_state);
430 ret = tevent_wakeup_recv(subreq);
433 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
436 if (!smbsock_any_connect_send_next(req, state)) {
439 if (state->num_sent >= state->num_addrs) {
442 subreq = tevent_wakeup_send(state, state->ev,
443 tevent_timeval_set(0, 10000));
444 if (tevent_req_nomem(subreq, req)) {
447 tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
450 static bool smbsock_any_connect_send_next(
451 struct tevent_req *req, struct smbsock_any_connect_state *state)
453 struct tevent_req *subreq;
455 if (state->num_sent >= state->num_addrs) {
456 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
459 subreq = smbsock_connect_send(
460 state->requests, state->ev, &state->addrs[state->num_sent],
461 (state->called_names != NULL)
462 ? state->called_names[state->num_sent] : NULL,
464 if (tevent_req_nomem(subreq, req)) {
467 tevent_req_set_callback(subreq, smbsock_any_connect_connected, req);
469 state->requests[state->num_sent] = subreq;
470 state->num_sent += 1;
475 static void smbsock_any_connect_connected(struct tevent_req *subreq)
477 struct tevent_req *req = tevent_req_callback_data(
478 subreq, struct tevent_req);
479 struct smbsock_any_connect_state *state = tevent_req_data(
480 req, struct smbsock_any_connect_state);
485 size_t chosen_index = 0;
487 for (i=0; i<state->num_sent; i++) {
488 if (state->requests[i] == subreq) {
493 if (i == state->num_sent) {
494 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
498 status = smbsock_connect_recv(subreq, &fd, &port);
501 state->requests[chosen_index] = NULL;
503 if (NT_STATUS_IS_OK(status)) {
505 * This will kill all the other requests
507 TALLOC_FREE(state->requests);
510 state->chosen_index = chosen_index;
511 tevent_req_done(req);
515 state->num_received += 1;
516 if (state->num_received <= state->num_addrs) {
518 * More addrs pending, wait for the others
524 * This is the last response, none succeeded.
526 tevent_req_nterror(req, status);
530 NTSTATUS smbsock_any_connect_recv(struct tevent_req *req, int *pfd,
531 size_t *chosen_index, uint16_t *port)
533 struct smbsock_any_connect_state *state = tevent_req_data(
534 req, struct smbsock_any_connect_state);
537 if (tevent_req_is_nterror(req, &status)) {
541 if (chosen_index != NULL) {
542 *chosen_index = state->chosen_index;
550 NTSTATUS smbsock_any_connect(const struct sockaddr_storage *addrs,
551 const char **called_names, size_t num_addrs,
552 int *pfd, size_t *chosen_index, uint16_t *port)
554 TALLOC_CTX *frame = talloc_stackframe();
555 struct event_context *ev;
556 struct tevent_req *req;
557 NTSTATUS status = NT_STATUS_NO_MEMORY;
559 ev = event_context_init(frame);
563 req = smbsock_any_connect_send(frame, ev, addrs, called_names,
568 if (!tevent_req_poll_ntstatus(req, ev, &status)) {
571 status = smbsock_any_connect_recv(req, pfd, chosen_index, port);