packet->qdcount = 1;
packet->arcount = 1;
- packet->operation = NBT_OPCODE_REGISTER;
+ if (io->in.multi_homed) {
+ packet->operation = NBT_OPCODE_MULTI_HOME_REG;
+ } else {
+ packet->operation = NBT_OPCODE_REGISTER;
+ }
if (io->in.broadcast) {
packet->operation |= NBT_FLAG_BROADCAST;
}
state->io->in.nb_flags = io->in.nb_flags;
state->io->in.register_demand = False;
state->io->in.broadcast = True;
+ state->io->in.multi_homed = False;
state->io->in.ttl = io->in.ttl;
state->io->in.timeout = 1;
state->io->in.retries = 2;
struct composite_context *c = nbt_name_register_bcast_send(nbtsock, io);
return nbt_name_register_bcast_recv(c);
}
+
+
+/*
+ a wins name register with multiple WINS servers and multiple
+ addresses to register. Try each WINS server in turn, until we get a
+ reply for each address
+*/
+struct register_wins_state {
+ struct nbt_name_socket *nbtsock;
+ struct nbt_name_register *io;
+ const char **wins_servers;
+ const char **addresses;
+ int address_idx;
+ struct nbt_name_request *req;
+};
+
+
+/*
+ state handler for WINS multi-homed multi-server name register
+*/
+static void name_register_wins_handler(struct nbt_name_request *req)
+{
+ struct composite_context *c = talloc_get_type(req->async.private,
+ struct composite_context);
+ struct register_wins_state *state = talloc_get_type(c->private,
+ struct register_wins_state);
+ NTSTATUS status;
+
+ status = nbt_name_register_recv(state->req, state, state->io);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+ /* the register timed out - try the next WINS server */
+ state->wins_servers++;
+ state->address_idx = 0;
+ if (state->wins_servers[0] == NULL) {
+ c->state = SMBCLI_REQUEST_ERROR;
+ c->status = status;
+ goto done;
+ }
+ state->io->in.dest_addr = state->wins_servers[0];
+ state->io->in.address = state->addresses[0];
+ state->req = nbt_name_register_send(state->nbtsock, state->io);
+ if (state->req == NULL) {
+ c->state = SMBCLI_REQUEST_ERROR;
+ c->status = NT_STATUS_NO_MEMORY;
+ } else {
+ state->req->async.fn = name_register_wins_handler;
+ state->req->async.private = c;
+ }
+ } else if (!NT_STATUS_IS_OK(status)) {
+ c->state = SMBCLI_REQUEST_ERROR;
+ c->status = status;
+ } else {
+ if (state->io->out.rcode == 0 &&
+ state->addresses[state->address_idx+1] != NULL) {
+ /* register our next address */
+ state->io->in.address = state->addresses[++(state->address_idx)];
+ state->req = nbt_name_register_send(state->nbtsock, state->io);
+ if (state->req == NULL) {
+ c->state = SMBCLI_REQUEST_ERROR;
+ c->status = NT_STATUS_NO_MEMORY;
+ } else {
+ state->req->async.fn = name_register_wins_handler;
+ state->req->async.private = c;
+ }
+ } else {
+ c->state = SMBCLI_REQUEST_DONE;
+ c->status = NT_STATUS_OK;
+ }
+ }
+
+done:
+ if (c->state >= SMBCLI_REQUEST_DONE &&
+ c->async.fn) {
+ c->async.fn(c);
+ }
+}
+
+/*
+ the async send call for a multi-server WINS register
+*/
+struct composite_context *nbt_name_register_wins_send(struct nbt_name_socket *nbtsock,
+ struct nbt_name_register_wins *io)
+{
+ struct composite_context *c;
+ struct register_wins_state *state;
+
+ c = talloc_zero(nbtsock, struct composite_context);
+ if (c == NULL) goto failed;
+
+ state = talloc(c, struct register_wins_state);
+ if (state == NULL) goto failed;
+
+ state->io = talloc(state, struct nbt_name_register);
+ if (state->io == NULL) goto failed;
+
+ state->wins_servers = str_list_copy(state, io->in.wins_servers);
+ if (state->wins_servers == NULL ||
+ state->wins_servers[0] == NULL) goto failed;
+
+ state->addresses = str_list_copy(state, io->in.addresses);
+ if (state->addresses == NULL ||
+ state->addresses[0] == NULL) goto failed;
+
+ state->io->in.name = io->in.name;
+ state->io->in.dest_addr = state->wins_servers[0];
+ state->io->in.address = io->in.addresses[0];
+ state->io->in.nb_flags = io->in.nb_flags;
+ state->io->in.broadcast = False;
+ state->io->in.register_demand = False;
+ state->io->in.multi_homed = (io->in.nb_flags & NBT_NM_GROUP)?False:True;
+ state->io->in.ttl = io->in.ttl;
+ state->io->in.timeout = 3;
+ state->io->in.retries = 2;
+
+ state->nbtsock = nbtsock;
+ state->address_idx = 0;
+
+ state->req = nbt_name_register_send(nbtsock, state->io);
+ if (state->req == NULL) goto failed;
+
+ state->req->async.fn = name_register_wins_handler;
+ state->req->async.private = c;
+
+ c->private = state;
+ c->state = SMBCLI_REQUEST_SEND;
+ c->event_ctx = nbtsock->event_ctx;
+
+ return c;
+
+failed:
+ talloc_free(c);
+ return NULL;
+}
+
+/*
+ multi-homed WINS name register - recv side
+*/
+NTSTATUS nbt_name_register_wins_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+ struct nbt_name_register_wins *io)
+{
+ NTSTATUS status;
+ status = composite_wait(c);
+ if (NT_STATUS_IS_OK(status)) {
+ struct register_wins_state *state =
+ talloc_get_type(c->private, struct register_wins_state);
+ io->out.wins_server = talloc_steal(mem_ctx, state->wins_servers[0]);
+ io->out.rcode = state->io->out.rcode;
+ }
+ talloc_free(c);
+ return status;
+}
+
+/*
+ multi-homed WINS register - sync interface
+*/
+NTSTATUS nbt_name_register_wins(struct nbt_name_socket *nbtsock,
+ TALLOC_CTX *mem_ctx,
+ struct nbt_name_register_wins *io)
+{
+ struct composite_context *c = nbt_name_register_wins_send(nbtsock, io);
+ return nbt_name_register_wins_recv(c, mem_ctx, io);
+}
}
DLIST_REMOVE(nbtsock->send_queue, req);
+ req->state = NBT_REQUEST_WAIT;
if (req->is_reply) {
talloc_free(req);
} else {
- req->state = NBT_REQUEST_WAIT;
EVENT_FD_READABLE(nbtsock->fde);
nbtsock->num_pending++;
}
req->te = event_add_timed(req->nbtsock->event_ctx, req,
timeval_add(&t, req->timeout, 0),
nbt_name_socket_timeout, req);
- DLIST_ADD_END(req->nbtsock->send_queue, req, struct nbt_name_request *);
+ if (req->state != NBT_REQUEST_SEND) {
+ req->state = NBT_REQUEST_SEND;
+ DLIST_ADD_END(req->nbtsock->send_queue, req,
+ struct nbt_name_request *);
+ }
EVENT_FD_WRITEABLE(req->nbtsock->fde);
return;
}
/* find the matching request */
req = idr_find(nbtsock->idr, packet->name_trn_id);
if (req == NULL) {
- DEBUG(2,("Failed to match request for incoming name packet id 0x%04x\n",
- packet->name_trn_id));
+ if (nbtsock->unexpected.handler) {
+ nbtsock->unexpected.handler(nbtsock, packet, src_addr, src_port);
+ } else {
+ DEBUG(2,("Failed to match request for incoming name packet id 0x%04x on %p\n",
+ packet->name_trn_id, nbtsock));
+ }
talloc_free(tmp_ctx);
return;
}
req->num_retries = 0;
req->received_wack = True;
if (packet->answers[0].ttl != 0) {
- req->timeout = MIN(packet->answers[0].ttl, 20);
+ req->timeout = MIN(packet->answers[0].ttl, 20);
}
- req->te = event_add_timed(req->nbtsock->event_ctx, req,
- timeval_current_ofs(req->timeout, 0),
- nbt_name_socket_timeout, req);
- DLIST_ADD_END(req->nbtsock->send_queue, req, struct nbt_name_request *);
- EVENT_FD_WRITEABLE(req->nbtsock->fde);
+ req->te = event_add_timed(req->nbtsock->event_ctx, req,
+ timeval_current_ofs(req->timeout, 0),
+ nbt_name_socket_timeout, req);
talloc_free(tmp_ctx);
return;
}
nbtsock->send_queue = NULL;
nbtsock->num_pending = 0;
nbtsock->incoming.handler = NULL;
+ nbtsock->unexpected.handler = NULL;
nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
socket_get_fd(nbtsock->sock), 0,
UINT16_MAX);
}
if (id == -1) goto failed;
+
request->name_trn_id = id;
req->name_trn_id = id;
git.samba.org / kai / samba-autobuild / .git / commitdiff