idr_remove(req->nbtsock->idr, req->name_trn_id);
req->name_trn_id = 0;
}
- if (req->te) {
- talloc_free(req->te);
- req->te = NULL;
- }
+ TALLOC_FREE(req->te);
if (req->nbtsock->send_queue == NULL) {
- EVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
+ TEVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
}
if (req->nbtsock->num_pending == 0 &&
req->nbtsock->incoming.handler == NULL) {
- EVENT_FD_NOT_READABLE(req->nbtsock->fde);
+ TEVENT_FD_NOT_READABLE(req->nbtsock->fde);
}
return 0;
}
if (req->is_reply) {
talloc_free(req);
} else {
- EVENT_FD_READABLE(nbtsock->fde);
+ TEVENT_FD_READABLE(nbtsock->fde);
nbtsock->num_pending++;
}
}
- EVENT_FD_NOT_WRITEABLE(nbtsock->fde);
+ TEVENT_FD_NOT_WRITEABLE(nbtsock->fde);
talloc_free(tmp_ctx);
return;
/*
handle a request timeout
*/
-static void nbt_name_socket_timeout(struct event_context *ev, struct timed_event *te,
- struct timeval t, void *private)
+static void nbt_name_socket_timeout(struct tevent_context *ev, struct tevent_timer *te,
+ struct timeval t, void *private_data)
{
- struct nbt_name_request *req = talloc_get_type(private,
+ struct nbt_name_request *req = talloc_get_type(private_data,
struct nbt_name_request);
if (req->num_retries != 0) {
req->num_retries--;
- req->te = event_add_timed(req->nbtsock->event_ctx, req,
- timeval_add(&t, req->timeout, 0),
- nbt_name_socket_timeout, req);
+ req->te = tevent_add_timer(req->nbtsock->event_ctx, req,
+ timeval_add(&t, req->timeout, 0),
+ nbt_name_socket_timeout, req);
if (req->state != NBT_REQUEST_SEND) {
req->state = NBT_REQUEST_SEND;
- DLIST_ADD_END(req->nbtsock->send_queue, req,
- struct nbt_name_request *);
+ DLIST_ADD_END(req->nbtsock->send_queue, req);
}
- EVENT_FD_WRITEABLE(req->nbtsock->fde);
+ TEVENT_FD_WRITEABLE(req->nbtsock->fde);
return;
}
}
/* parse the request */
- ndr_err = ndr_pull_struct_blob(&blob, packet, nbtsock->iconv_convenience, packet,
+ ndr_err = ndr_pull_struct_blob(&blob, packet, packet,
(ndr_pull_flags_fn_t)ndr_pull_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
return;
}
+ talloc_steal(req, packet);
+ talloc_steal(req, src);
+ talloc_free(tmp_ctx);
+ nbt_name_socket_handle_response_packet(req, packet, src);
+}
+
+void nbt_name_socket_handle_response_packet(struct nbt_name_request *req,
+ struct nbt_name_packet *packet,
+ struct socket_address *src)
+{
/* if this is a WACK response, this we need to go back to waiting,
but perhaps increase the timeout */
if ((packet->operation & NBT_OPCODE) == NBT_OPCODE_WACK) {
+ uint32_t ttl;
if (req->received_wack || packet->ancount < 1) {
nbt_name_request_destructor(req);
req->status = NT_STATUS_INVALID_NETWORK_RESPONSE;
has received our request */
req->num_retries = 0;
req->received_wack = true;
- /* although there can be a timeout in the packet, w2k3 screws it up,
- so better to set it ourselves */
- req->timeout = nbtsock->wack_timeout;
- 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);
+ /*
+ * there is a timeout in the packet,
+ * it is 5 + 4 * num_old_addresses
+ *
+ * although w2k3 screws it up
+ * and uses num_old_addresses = 0
+ *
+ * so we better fallback to the maximum
+ * of num_old_addresses = 25 if we got
+ * a timeout of less than 9s (5 + 4*1)
+ * or more than 105s (5 + 4*25).
+ */
+ ttl = packet->answers[0].ttl;
+ if ((ttl < (5 + 4*1)) || (ttl > (5 + 4*25))) {
+ ttl = 5 + 4*25;
+ }
+ req->timeout = ttl;
+ req->te = tevent_add_timer(req->nbtsock->event_ctx, req,
+ timeval_current_ofs(req->timeout, 0),
+ nbt_name_socket_timeout, req);
return;
}
/* if we don't want multiple replies then we are done */
if (req->allow_multiple_replies &&
req->num_replies < NBT_MAX_REPLIES) {
- talloc_free(tmp_ctx);
return;
}
req->status = NT_STATUS_OK;
done:
- talloc_free(tmp_ctx);
if (req->async.fn) {
req->async.fn(req);
}
/*
handle fd events on a nbt_name_socket
*/
-static void nbt_name_socket_handler(struct event_context *ev, struct fd_event *fde,
- uint16_t flags, void *private)
+static void nbt_name_socket_handler(struct tevent_context *ev, struct tevent_fd *fde,
+ uint16_t flags, void *private_data)
{
- struct nbt_name_socket *nbtsock = talloc_get_type(private,
+ struct nbt_name_socket *nbtsock = talloc_get_type(private_data,
struct nbt_name_socket);
- if (flags & EVENT_FD_WRITE) {
+ if (flags & TEVENT_FD_WRITE) {
nbt_name_socket_send(nbtsock);
}
- if (flags & EVENT_FD_READ) {
+ if (flags & TEVENT_FD_READ) {
nbt_name_socket_recv(nbtsock);
}
}
then operations will use that event context
*/
_PUBLIC_ struct nbt_name_socket *nbt_name_socket_init(TALLOC_CTX *mem_ctx,
- struct event_context *event_ctx,
- struct smb_iconv_convenience *iconv_convenience)
+ struct tevent_context *event_ctx)
{
struct nbt_name_socket *nbtsock;
NTSTATUS status;
nbtsock = talloc(mem_ctx, struct nbt_name_socket);
if (nbtsock == NULL) goto failed;
- nbtsock->event_ctx = talloc_reference(nbtsock, event_ctx);
+ nbtsock->event_ctx = event_ctx;
if (nbtsock->event_ctx == NULL) goto failed;
- status = socket_create("ip", SOCKET_TYPE_DGRAM, &nbtsock->sock, 0);
+ status = socket_create(nbtsock, "ip", SOCKET_TYPE_DGRAM,
+ &nbtsock->sock, 0);
if (!NT_STATUS_IS_OK(status)) goto failed;
socket_set_option(nbtsock->sock, "SO_BROADCAST", "1");
- talloc_steal(nbtsock, nbtsock->sock);
-
nbtsock->idr = idr_init(nbtsock);
if (nbtsock->idr == NULL) goto failed;
nbtsock->send_queue = NULL;
nbtsock->num_pending = 0;
- nbtsock->wack_timeout = 30;
nbtsock->incoming.handler = NULL;
nbtsock->unexpected.handler = NULL;
- nbtsock->iconv_convenience = iconv_convenience;
- nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
- socket_get_fd(nbtsock->sock), 0,
- nbt_name_socket_handler, nbtsock);
+ nbtsock->fde = tevent_add_fd(nbtsock->event_ctx, nbtsock,
+ socket_get_fd(nbtsock->sock), 0,
+ nbt_name_socket_handler, nbtsock);
return nbtsock;
req->is_reply = false;
req->timeout = timeout;
req->num_retries = retries;
- req->dest = dest;
- if (talloc_reference(req, dest) == NULL) goto failed;
+ req->dest = socket_address_copy(req, dest);
+ if (req->dest == NULL) goto failed;
/* we select a random transaction id unless the user supplied one */
if (request->name_trn_id == 0) {
request->name_trn_id = id;
req->name_trn_id = id;
- req->te = event_add_timed(nbtsock->event_ctx, req,
- timeval_current_ofs(req->timeout, 0),
- nbt_name_socket_timeout, req);
+ req->te = tevent_add_timer(nbtsock->event_ctx, req,
+ timeval_current_ofs(req->timeout, 0),
+ nbt_name_socket_timeout, req);
talloc_set_destructor(req, nbt_name_request_destructor);
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
- DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
+ DLIST_ADD_END(nbtsock->send_queue, req);
if (DEBUGLVL(10)) {
DEBUG(10,("Queueing nbt packet to %s:%d\n",
NDR_PRINT_DEBUG(nbt_name_packet, request);
}
- EVENT_FD_WRITEABLE(nbtsock->fde);
+ TEVENT_FD_WRITEABLE(nbtsock->fde);
return req;
NT_STATUS_HAVE_NO_MEMORY(req);
req->nbtsock = nbtsock;
- req->dest = dest;
- if (talloc_reference(req, dest) == NULL) goto failed;
+ req->dest = socket_address_copy(req, dest);
+ if (req>dest == NULL) goto failed;
req->state = NBT_REQUEST_SEND;
req->is_reply = true;
}
ndr_err = ndr_push_struct_blob(&req->encoded, req,
- req->nbtsock->iconv_convenience,
request,
(ndr_push_flags_fn_t)ndr_push_nbt_name_packet);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
return ndr_map_error2ntstatus(ndr_err);
}
- DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
+ DLIST_ADD_END(nbtsock->send_queue, req);
- EVENT_FD_WRITEABLE(nbtsock->fde);
+ TEVENT_FD_WRITEABLE(nbtsock->fde);
return NT_STATUS_OK;
if (!req) return NT_STATUS_NO_MEMORY;
while (req->state < NBT_REQUEST_DONE) {
- if (event_loop_once(req->nbtsock->event_ctx) != 0) {
+ if (tevent_loop_once(req->nbtsock->event_ctx) != 0) {
req->state = NBT_REQUEST_ERROR;
req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
break;
_PUBLIC_ NTSTATUS nbt_set_incoming_handler(struct nbt_name_socket *nbtsock,
void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
struct socket_address *),
- void *private)
+ void *private_data)
{
nbtsock->incoming.handler = handler;
- nbtsock->incoming.private_data = private;
- EVENT_FD_READABLE(nbtsock->fde);
+ nbtsock->incoming.private_data = private_data;
+ TEVENT_FD_READABLE(nbtsock->fde);
return NT_STATUS_OK;
}
+/*
+ setup a handler for unexpected requests
+*/
+NTSTATUS nbt_set_unexpected_handler(struct nbt_name_socket *nbtsock,
+ void (*handler)(struct nbt_name_socket *, struct nbt_name_packet *,
+ struct socket_address *),
+ void *private_data)
+{
+ nbtsock->unexpected.handler = handler;
+ nbtsock->unexpected.private_data = private_data;
+ TEVENT_FD_READABLE(nbtsock->fde);
+ return NT_STATUS_OK;
+}
/*
turn a NBT rcode into a NTSTATUS
git.samba.org / metze / samba / wip.git / blobdiff