1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-22 13:34:15 +03:00
samba-mirror/source3/libsmb/smbsock_connect.c
Stefan Metzmacher 058d84747e s3:libsmb: remove pending requests as early as possible via a smbsock_any_connect_cleanup() hook
Once we got an error or a valid connection we should destroy all other
connection attempts as early as possible.

BUG: https://bugzilla.samba.org/show_bug.cgi?id=11316

Signed-off-by: Stefan Metzmacher <metze@samba.org>
Reviewed-by: Volker Lendecke <vl@samba.org>
2015-06-12 17:08:17 +02:00

860 lines
22 KiB
C

/*
Unix SMB/CIFS implementation.
Connect to 445 and 139/nbsesssetup
Copyright (C) Volker Lendecke 2010
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "../lib/async_req/async_sock.h"
#include "../lib/util/tevent_ntstatus.h"
#include "../lib/util/tevent_unix.h"
#include "client.h"
#include "async_smb.h"
#include "../libcli/smb/read_smb.h"
#include "libsmb/nmblib.h"
struct cli_session_request_state {
struct tevent_context *ev;
int sock;
uint32_t len_hdr;
struct iovec iov[3];
uint8_t nb_session_response;
};
static void cli_session_request_sent(struct tevent_req *subreq);
static void cli_session_request_recvd(struct tevent_req *subreq);
static struct tevent_req *cli_session_request_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int sock,
const struct nmb_name *called,
const struct nmb_name *calling)
{
struct tevent_req *req, *subreq;
struct cli_session_request_state *state;
req = tevent_req_create(mem_ctx, &state,
struct cli_session_request_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
state->sock = sock;
state->iov[1].iov_base = name_mangle(
state, called->name, called->name_type);
if (tevent_req_nomem(state->iov[1].iov_base, req)) {
return tevent_req_post(req, ev);
}
state->iov[1].iov_len = name_len(
(unsigned char *)state->iov[1].iov_base,
talloc_get_size(state->iov[1].iov_base));
state->iov[2].iov_base = name_mangle(
state, calling->name, calling->name_type);
if (tevent_req_nomem(state->iov[2].iov_base, req)) {
return tevent_req_post(req, ev);
}
state->iov[2].iov_len = name_len(
(unsigned char *)state->iov[2].iov_base,
talloc_get_size(state->iov[2].iov_base));
_smb_setlen(((char *)&state->len_hdr),
state->iov[1].iov_len + state->iov[2].iov_len);
SCVAL((char *)&state->len_hdr, 0, 0x81);
state->iov[0].iov_base = &state->len_hdr;
state->iov[0].iov_len = sizeof(state->len_hdr);
subreq = writev_send(state, ev, NULL, sock, true, state->iov, 3);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, cli_session_request_sent, req);
return req;
}
static void cli_session_request_sent(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct cli_session_request_state *state = tevent_req_data(
req, struct cli_session_request_state);
ssize_t ret;
int err;
ret = writev_recv(subreq, &err);
TALLOC_FREE(subreq);
if (ret == -1) {
tevent_req_error(req, err);
return;
}
subreq = read_smb_send(state, state->ev, state->sock);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, cli_session_request_recvd, req);
}
static void cli_session_request_recvd(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct cli_session_request_state *state = tevent_req_data(
req, struct cli_session_request_state);
uint8_t *buf;
ssize_t ret;
int err;
ret = read_smb_recv(subreq, talloc_tos(), &buf, &err);
TALLOC_FREE(subreq);
if (ret < 4) {
ret = -1;
err = EIO;
}
if (ret == -1) {
tevent_req_error(req, err);
return;
}
/*
* In case of an error there is more information in the data
* portion according to RFC1002. We're not subtle enough to
* respond to the different error conditions, so drop the
* error info here.
*/
state->nb_session_response = CVAL(buf, 0);
tevent_req_done(req);
}
static bool cli_session_request_recv(struct tevent_req *req, int *err, uint8_t *resp)
{
struct cli_session_request_state *state = tevent_req_data(
req, struct cli_session_request_state);
if (tevent_req_is_unix_error(req, err)) {
return false;
}
*resp = state->nb_session_response;
return true;
}
struct nb_connect_state {
struct tevent_context *ev;
const struct sockaddr_storage *addr;
const char *called_name;
int sock;
struct tevent_req *session_subreq;
struct nmb_name called;
struct nmb_name calling;
};
static void nb_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state);
static void nb_connect_connected(struct tevent_req *subreq);
static void nb_connect_done(struct tevent_req *subreq);
static struct tevent_req *nb_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const struct sockaddr_storage *addr,
const char *called_name,
int called_type,
const char *calling_name,
int calling_type)
{
struct tevent_req *req, *subreq;
struct nb_connect_state *state;
req = tevent_req_create(mem_ctx, &state, struct nb_connect_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
state->called_name = called_name;
state->addr = addr;
state->sock = -1;
make_nmb_name(&state->called, called_name, called_type);
make_nmb_name(&state->calling, calling_name, calling_type);
tevent_req_set_cleanup_fn(req, nb_connect_cleanup);
subreq = open_socket_out_send(state, ev, addr, NBT_SMB_PORT, 5000);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, nb_connect_connected, req);
return req;
}
static void nb_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state)
{
struct nb_connect_state *state = tevent_req_data(
req, struct nb_connect_state);
/*
* we need to free a pending request before closing the
* socket, see bug #11141
*/
TALLOC_FREE(state->session_subreq);
if (req_state == TEVENT_REQ_DONE) {
/*
* we keep the socket open for the caller to use
*/
return;
}
if (state->sock != -1) {
close(state->sock);
state->sock = -1;
}
return;
}
static void nb_connect_connected(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct nb_connect_state *state = tevent_req_data(
req, struct nb_connect_state);
NTSTATUS status;
status = open_socket_out_recv(subreq, &state->sock);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
tevent_req_nterror(req, status);
return;
}
subreq = cli_session_request_send(state, state->ev, state->sock,
&state->called, &state->calling);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, nb_connect_done, req);
state->session_subreq = subreq;
}
static void nb_connect_done(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct nb_connect_state *state = tevent_req_data(
req, struct nb_connect_state);
bool ret;
int err;
uint8_t resp;
state->session_subreq = NULL;
ret = cli_session_request_recv(subreq, &err, &resp);
TALLOC_FREE(subreq);
if (!ret) {
tevent_req_nterror(req, map_nt_error_from_unix(err));
return;
}
/*
* RFC1002: 0x82 - POSITIVE SESSION RESPONSE
*/
if (resp != 0x82) {
/*
* The server did not like our session request
*/
close(state->sock);
state->sock = -1;
if (strequal(state->called_name, "*SMBSERVER")) {
/*
* Here we could try a name status request and
* use the first 0x20 type name.
*/
tevent_req_nterror(
req, NT_STATUS_RESOURCE_NAME_NOT_FOUND);
return;
}
/*
* We could be subtle and distinguish between
* different failure modes, but what we do here
* instead is just retry with *SMBSERVER type 0x20.
*/
state->called_name = "*SMBSERVER";
make_nmb_name(&state->called, state->called_name, 0x20);
subreq = open_socket_out_send(state, state->ev, state->addr,
NBT_SMB_PORT, 5000);
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, nb_connect_connected, req);
return;
}
tevent_req_done(req);
return;
}
static NTSTATUS nb_connect_recv(struct tevent_req *req, int *sock)
{
struct nb_connect_state *state = tevent_req_data(
req, struct nb_connect_state);
NTSTATUS status;
if (tevent_req_is_nterror(req, &status)) {
tevent_req_received(req);
return status;
}
*sock = state->sock;
state->sock = -1;
tevent_req_received(req);
return NT_STATUS_OK;
}
struct smbsock_connect_state {
struct tevent_context *ev;
const struct sockaddr_storage *addr;
const char *called_name;
uint8_t called_type;
const char *calling_name;
uint8_t calling_type;
struct tevent_req *req_139;
struct tevent_req *req_445;
int sock;
uint16_t port;
};
static void smbsock_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state);
static void smbsock_connect_connected(struct tevent_req *subreq);
static void smbsock_connect_do_139(struct tevent_req *subreq);
struct tevent_req *smbsock_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const struct sockaddr_storage *addr,
uint16_t port,
const char *called_name,
int called_type,
const char *calling_name,
int calling_type)
{
struct tevent_req *req;
struct smbsock_connect_state *state;
req = tevent_req_create(mem_ctx, &state, struct smbsock_connect_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
state->addr = addr;
state->sock = -1;
state->called_name =
(called_name != NULL) ? called_name : "*SMBSERVER";
state->called_type =
(called_type != -1) ? called_type : 0x20;
state->calling_name =
(calling_name != NULL) ? calling_name : lp_netbios_name();
state->calling_type =
(calling_type != -1) ? calling_type : 0x00;
tevent_req_set_cleanup_fn(req, smbsock_connect_cleanup);
if (port == NBT_SMB_PORT) {
state->req_139 = nb_connect_send(state, state->ev, state->addr,
state->called_name,
state->called_type,
state->calling_name,
state->calling_type);
if (tevent_req_nomem(state->req_139, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(
state->req_139, smbsock_connect_connected, req);
return req;
}
if (port != 0) {
state->req_445 = open_socket_out_send(state, ev, addr, port,
5000);
if (tevent_req_nomem(state->req_445, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(
state->req_445, smbsock_connect_connected, req);
return req;
}
/*
* port==0, try both
*/
state->req_445 = open_socket_out_send(state, ev, addr, TCP_SMB_PORT, 5000);
if (tevent_req_nomem(state->req_445, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(state->req_445, smbsock_connect_connected,
req);
/*
* After 5 msecs, fire the 139 (NBT) request
*/
state->req_139 = tevent_wakeup_send(
state, ev, timeval_current_ofs(0, 5000));
if (tevent_req_nomem(state->req_139, req)) {
TALLOC_FREE(state->req_445);
return tevent_req_post(req, ev);
}
tevent_req_set_callback(state->req_139, smbsock_connect_do_139,
req);
return req;
}
static void smbsock_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state)
{
struct smbsock_connect_state *state = tevent_req_data(
req, struct smbsock_connect_state);
/*
* we need to free a pending request before closing the
* socket, see bug #11141
*/
TALLOC_FREE(state->req_445);
TALLOC_FREE(state->req_139);
if (req_state == TEVENT_REQ_DONE) {
/*
* we keep the socket open for the caller to use
*/
return;
}
if (state->sock != -1) {
close(state->sock);
state->sock = -1;
}
return;
}
static void smbsock_connect_do_139(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct smbsock_connect_state *state = tevent_req_data(
req, struct smbsock_connect_state);
bool ret;
ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq);
if (!ret) {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
state->req_139 = nb_connect_send(state, state->ev, state->addr,
state->called_name,
state->called_type,
state->calling_name,
state->calling_type);
if (tevent_req_nomem(state->req_139, req)) {
return;
}
tevent_req_set_callback(state->req_139, smbsock_connect_connected,
req);
}
static void smbsock_connect_connected(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct smbsock_connect_state *state = tevent_req_data(
req, struct smbsock_connect_state);
struct tevent_req *unfinished_req;
NTSTATUS status;
if (subreq == state->req_445) {
status = open_socket_out_recv(subreq, &state->sock);
TALLOC_FREE(state->req_445);
unfinished_req = state->req_139;
state->port = TCP_SMB_PORT;
} else if (subreq == state->req_139) {
status = nb_connect_recv(subreq, &state->sock);
TALLOC_FREE(state->req_139);
unfinished_req = state->req_445;
state->port = NBT_SMB_PORT;
} else {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
if (NT_STATUS_IS_OK(status)) {
TALLOC_FREE(unfinished_req);
state->req_139 = NULL;
state->req_445 = NULL;
tevent_req_done(req);
return;
}
if (unfinished_req == NULL) {
/*
* Both requests failed
*/
tevent_req_nterror(req, status);
return;
}
/*
* Do nothing, wait for the second request to come here.
*/
}
NTSTATUS smbsock_connect_recv(struct tevent_req *req, int *sock,
uint16_t *ret_port)
{
struct smbsock_connect_state *state = tevent_req_data(
req, struct smbsock_connect_state);
NTSTATUS status;
if (tevent_req_is_nterror(req, &status)) {
tevent_req_received(req);
return status;
}
*sock = state->sock;
state->sock = -1;
if (ret_port != NULL) {
*ret_port = state->port;
}
tevent_req_received(req);
return NT_STATUS_OK;
}
NTSTATUS smbsock_connect(const struct sockaddr_storage *addr, uint16_t port,
const char *called_name, int called_type,
const char *calling_name, int calling_type,
int *pfd, uint16_t *ret_port, int sec_timeout)
{
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_context *ev;
struct tevent_req *req;
NTSTATUS status = NT_STATUS_NO_MEMORY;
ev = samba_tevent_context_init(frame);
if (ev == NULL) {
goto fail;
}
req = smbsock_connect_send(frame, ev, addr, port,
called_name, called_type,
calling_name, calling_type);
if (req == NULL) {
goto fail;
}
if ((sec_timeout != 0) &&
!tevent_req_set_endtime(
req, ev, timeval_current_ofs(sec_timeout, 0))) {
goto fail;
}
if (!tevent_req_poll_ntstatus(req, ev, &status)) {
goto fail;
}
status = smbsock_connect_recv(req, pfd, ret_port);
fail:
TALLOC_FREE(frame);
return status;
}
struct smbsock_any_connect_state {
struct tevent_context *ev;
const struct sockaddr_storage *addrs;
const char **called_names;
int *called_types;
const char **calling_names;
int *calling_types;
size_t num_addrs;
uint16_t port;
struct tevent_req **requests;
size_t num_sent;
size_t num_received;
int fd;
uint16_t chosen_port;
size_t chosen_index;
};
static void smbsock_any_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state);
static bool smbsock_any_connect_send_next(
struct tevent_req *req, struct smbsock_any_connect_state *state);
static void smbsock_any_connect_trynext(struct tevent_req *subreq);
static void smbsock_any_connect_connected(struct tevent_req *subreq);
struct tevent_req *smbsock_any_connect_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const struct sockaddr_storage *addrs,
const char **called_names,
int *called_types,
const char **calling_names,
int *calling_types,
size_t num_addrs, uint16_t port)
{
struct tevent_req *req, *subreq;
struct smbsock_any_connect_state *state;
req = tevent_req_create(mem_ctx, &state,
struct smbsock_any_connect_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
state->addrs = addrs;
state->num_addrs = num_addrs;
state->called_names = called_names;
state->called_types = called_types;
state->calling_names = calling_names;
state->calling_types = calling_types;
state->port = port;
state->fd = -1;
tevent_req_set_cleanup_fn(req, smbsock_any_connect_cleanup);
if (num_addrs == 0) {
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
return tevent_req_post(req, ev);
}
state->requests = talloc_zero_array(state, struct tevent_req *,
num_addrs);
if (tevent_req_nomem(state->requests, req)) {
return tevent_req_post(req, ev);
}
if (!smbsock_any_connect_send_next(req, state)) {
return tevent_req_post(req, ev);
}
if (state->num_sent >= state->num_addrs) {
return req;
}
subreq = tevent_wakeup_send(state, ev, timeval_current_ofs(0, 10000));
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
return req;
}
static void smbsock_any_connect_cleanup(struct tevent_req *req,
enum tevent_req_state req_state)
{
struct smbsock_any_connect_state *state = tevent_req_data(
req, struct smbsock_any_connect_state);
TALLOC_FREE(state->requests);
if (req_state == TEVENT_REQ_DONE) {
/*
* Keep the socket open for the caller.
*/
return;
}
if (state->fd != -1) {
close(state->fd);
state->fd = -1;
}
}
static void smbsock_any_connect_trynext(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct smbsock_any_connect_state *state = tevent_req_data(
req, struct smbsock_any_connect_state);
bool ret;
ret = tevent_wakeup_recv(subreq);
TALLOC_FREE(subreq);
if (!ret) {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
if (!smbsock_any_connect_send_next(req, state)) {
return;
}
if (state->num_sent >= state->num_addrs) {
return;
}
subreq = tevent_wakeup_send(state, state->ev,
tevent_timeval_set(0, 10000));
if (tevent_req_nomem(subreq, req)) {
return;
}
tevent_req_set_callback(subreq, smbsock_any_connect_trynext, req);
}
static bool smbsock_any_connect_send_next(
struct tevent_req *req, struct smbsock_any_connect_state *state)
{
struct tevent_req *subreq;
if (state->num_sent >= state->num_addrs) {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return false;
}
subreq = smbsock_connect_send(
state->requests, state->ev, &state->addrs[state->num_sent],
state->port,
(state->called_names != NULL)
? state->called_names[state->num_sent] : NULL,
(state->called_types != NULL)
? state->called_types[state->num_sent] : -1,
(state->calling_names != NULL)
? state->calling_names[state->num_sent] : NULL,
(state->calling_types != NULL)
? state->calling_types[state->num_sent] : -1);
if (tevent_req_nomem(subreq, req)) {
return false;
}
tevent_req_set_callback(subreq, smbsock_any_connect_connected, req);
state->requests[state->num_sent] = subreq;
state->num_sent += 1;
return true;
}
static void smbsock_any_connect_connected(struct tevent_req *subreq)
{
struct tevent_req *req = tevent_req_callback_data(
subreq, struct tevent_req);
struct smbsock_any_connect_state *state = tevent_req_data(
req, struct smbsock_any_connect_state);
NTSTATUS status;
int fd;
uint16_t chosen_port;
size_t i;
size_t chosen_index = 0;
for (i=0; i<state->num_sent; i++) {
if (state->requests[i] == subreq) {
chosen_index = i;
break;
}
}
if (i == state->num_sent) {
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
status = smbsock_connect_recv(subreq, &fd, &chosen_port);
TALLOC_FREE(subreq);
state->requests[chosen_index] = NULL;
if (NT_STATUS_IS_OK(status)) {
/*
* tevent_req_done() will kill all the other requests
* via smbsock_any_connect_cleanup().
*/
state->fd = fd;
state->chosen_port = chosen_port;
state->chosen_index = chosen_index;
tevent_req_done(req);
return;
}
state->num_received += 1;
if (state->num_received < state->num_addrs) {
/*
* More addrs pending, wait for the others
*/
return;
}
/*
* This is the last response, none succeeded.
*/
tevent_req_nterror(req, status);
return;
}
NTSTATUS smbsock_any_connect_recv(struct tevent_req *req, int *pfd,
size_t *chosen_index,
uint16_t *chosen_port)
{
struct smbsock_any_connect_state *state = tevent_req_data(
req, struct smbsock_any_connect_state);
NTSTATUS status;
if (tevent_req_is_nterror(req, &status)) {
tevent_req_received(req);
return status;
}
*pfd = state->fd;
state->fd = -1;
if (chosen_index != NULL) {
*chosen_index = state->chosen_index;
}
if (chosen_port != NULL) {
*chosen_port = state->chosen_port;
}
tevent_req_received(req);
return NT_STATUS_OK;
}
NTSTATUS smbsock_any_connect(const struct sockaddr_storage *addrs,
const char **called_names,
int *called_types,
const char **calling_names,
int *calling_types,
size_t num_addrs,
uint16_t port,
int sec_timeout,
int *pfd, size_t *chosen_index,
uint16_t *chosen_port)
{
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_context *ev;
struct tevent_req *req;
NTSTATUS status = NT_STATUS_NO_MEMORY;
ev = samba_tevent_context_init(frame);
if (ev == NULL) {
goto fail;
}
req = smbsock_any_connect_send(frame, ev, addrs,
called_names, called_types,
calling_names, calling_types,
num_addrs, port);
if (req == NULL) {
goto fail;
}
if ((sec_timeout != 0) &&
!tevent_req_set_endtime(
req, ev, timeval_current_ofs(sec_timeout, 0))) {
goto fail;
}
if (!tevent_req_poll_ntstatus(req, ev, &status)) {
goto fail;
}
status = smbsock_any_connect_recv(req, pfd, chosen_index, chosen_port);
fail:
TALLOC_FREE(frame);
return status;
}