+ return winsdb_modify(winssrv->wins_db, rec, modify_flags);
+}
+
+/*
+ do a sgroup merge
+*/
+static uint8_t wins_sgroup_merge(struct nbt_name_socket *nbtsock,
+ struct nbt_name_packet *packet,
+ struct winsdb_record *rec,
+ const char *address,
+ const struct socket_address *src)
+{
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+ struct nbtd_interface);
+ struct wins_server *winssrv = iface->nbtsrv->winssrv;
+ uint32_t ttl = wins_server_ttl(winssrv, packet->additional[0].ttl);
+
+ rec->expire_time = time(NULL) + ttl;
+ rec->registered_by = src->addr;
+
+ rec->addresses = winsdb_addr_list_add(winssrv->wins_db,
+ rec, rec->addresses,
+ address,
+ winssrv->wins_db->local_owner,
+ rec->expire_time,
+ true);
+ if (rec->addresses == NULL) return NBT_RCODE_SVR;
+
+ DEBUG(5,("WINS: sgroup merge of %s at %s\n",
+ nbt_name_string(packet, rec->name), address));
+
+ return winsdb_modify(winssrv->wins_db, rec, WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP);
+}
+
+struct nbtd_wins_wack_state {
+ struct nbtd_wins_wack_state *prev, *next;
+ struct wins_server *winssrv;
+ struct nbt_name_socket *nbtsock;
+ struct nbtd_interface *iface;
+ struct nbt_name_packet *request_packet;
+ struct winsdb_record *rec;
+ struct socket_address *src;
+ const char *reg_address;
+ enum wrepl_name_type new_type;
+ struct wins_challenge_io io;
+ NTSTATUS status;
+};
+
+static int nbtd_wins_wack_state_destructor(struct nbtd_wins_wack_state *s)
+{
+ DLIST_REMOVE(s->iface->wack_queue, s);
+ return 0;
+}
+
+static bool wins_check_wack_queue(struct nbtd_interface *iface,
+ struct nbt_name_packet *packet,
+ struct socket_address *src)
+{
+ struct nbtd_wins_wack_state *s;
+
+ for (s= iface->wack_queue; s; s = s->next) {
+ if (packet->name_trn_id != s->request_packet->name_trn_id) {
+ continue;
+ }
+ if (packet->operation != s->request_packet->operation) {
+ continue;
+ }
+ if (src->port != s->src->port) {
+ continue;
+ }
+ if (strcmp(src->addr, s->src->addr) != 0) {
+ continue;
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ deny a registration request
+*/
+static void wins_wack_deny(struct nbtd_wins_wack_state *s)
+{
+ nbtd_name_registration_reply(s->nbtsock, s->request_packet,
+ s->src, NBT_RCODE_ACT);
+ DEBUG(4,("WINS: denied name registration request for %s from %s:%d\n",
+ nbt_name_string(s, s->rec->name), s->src->addr, s->src->port));
+ talloc_free(s);
+}
+
+/*
+ allow a registration request
+*/
+static void wins_wack_allow(struct nbtd_wins_wack_state *s)
+{
+ NTSTATUS status;
+ uint32_t ttl = wins_server_ttl(s->winssrv, s->request_packet->additional[0].ttl);
+ struct winsdb_record *rec = s->rec, *rec2;
+ uint32_t i,j;
+
+ status = winsdb_lookup(s->winssrv->wins_db, rec->name, s, &rec2);
+ if (!NT_STATUS_IS_OK(status) ||
+ rec2->version != rec->version ||
+ strcmp(rec2->wins_owner, rec->wins_owner) != 0) {
+ DEBUG(5,("WINS: record %s changed during WACK - failing registration\n",
+ nbt_name_string(s, rec->name)));
+ wins_wack_deny(s);
+ return;
+ }
+
+ /*
+ * if the old name owner doesn't hold the name anymore
+ * handle the request as new registration for the new name owner
+ */
+ if (!NT_STATUS_IS_OK(s->status)) {
+ uint8_t rcode;
+
+ winsdb_delete(s->winssrv->wins_db, rec);
+ rcode = wins_register_new(s->nbtsock, s->request_packet, s->src, s->new_type);
+ if (rcode != NBT_RCODE_OK) {
+ DEBUG(1,("WINS: record %s failed to register as new during WACK\n",
+ nbt_name_string(s, rec->name)));
+ wins_wack_deny(s);
+ return;
+ }
+ goto done;
+ }
+
+ rec->expire_time = time(NULL) + ttl;
+ rec->registered_by = s->src->addr;
+
+ /*
+ * now remove all addresses that the client doesn't hold anymore
+ * and update the time stamp and owner for the ones that are still there
+ */
+ for (i=0; rec->addresses[i]; i++) {
+ bool found = false;
+ for (j=0; j < s->io.out.num_addresses; j++) {
+ if (strcmp(rec->addresses[i]->address, s->io.out.addresses[j]) != 0) continue;
+
+ found = true;
+ break;
+ }
+ if (found) {
+ rec->addresses = winsdb_addr_list_add(s->winssrv->wins_db,
+ rec, rec->addresses,
+ s->reg_address,
+ s->winssrv->wins_db->local_owner,
+ rec->expire_time,
+ true);
+ if (rec->addresses == NULL) goto failed;
+ continue;
+ }
+
+ winsdb_addr_list_remove(rec->addresses, rec->addresses[i]->address);
+ }
+
+ rec->addresses = winsdb_addr_list_add(s->winssrv->wins_db,
+ rec, rec->addresses,
+ s->reg_address,
+ s->winssrv->wins_db->local_owner,
+ rec->expire_time,
+ true);
+ if (rec->addresses == NULL) goto failed;
+
+ /* if we have more than one address, this becomes implicit a MHOMED record */
+ if (winsdb_addr_list_length(rec->addresses) > 1) {
+ rec->type = WREPL_TYPE_MHOMED;
+ }
+
+ winsdb_modify(s->winssrv->wins_db, rec, WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP);
+
+ DEBUG(4,("WINS: accepted registration of %s with address %s\n",
+ nbt_name_string(s, rec->name), s->reg_address));
+
+done:
+ nbtd_name_registration_reply(s->nbtsock, s->request_packet,
+ s->src, NBT_RCODE_OK);
+failed:
+ talloc_free(s);
+}
+
+/*
+ called when a name query to a current owner completes
+*/
+static void wack_wins_challenge_handler(struct composite_context *c_req)
+{
+ struct nbtd_wins_wack_state *s = talloc_get_type(c_req->async.private_data,
+ struct nbtd_wins_wack_state);
+ bool found;
+ uint32_t i;
+
+ s->status = wins_challenge_recv(c_req, s, &s->io);
+
+ /*
+ * if the owner denies it holds the name, then allow
+ * the registration
+ */
+ if (!NT_STATUS_IS_OK(s->status)) {
+ wins_wack_allow(s);
+ return;
+ }
+
+ if (s->new_type == WREPL_TYPE_GROUP || s->new_type == WREPL_TYPE_SGROUP) {
+ DEBUG(1,("WINS: record %s failed to register as group type(%u) during WACK, it's still type(%u)\n",
+ nbt_name_string(s, s->rec->name), s->new_type, s->rec->type));
+ wins_wack_deny(s);
+ return;
+ }
+
+ /*
+ * if the owner still wants the name and doesn't reply
+ * with the address trying to be registered, then deny
+ * the registration
+ */
+ found = false;
+ for (i=0; i < s->io.out.num_addresses; i++) {
+ if (strcmp(s->reg_address, s->io.out.addresses[i]) != 0) continue;
+
+ found = true;
+ break;
+ }
+ if (!found) {
+ wins_wack_deny(s);
+ return;
+ }
+
+ wins_wack_allow(s);
+ return;
+}
+
+
+/*
+ a client has asked to register a unique name that someone else owns. We
+ need to ask each of the current owners if they still want it. If they do
+ then reject the registration, otherwise allow it
+*/
+static void wins_register_wack(struct nbt_name_socket *nbtsock,
+ struct nbt_name_packet *packet,
+ struct winsdb_record *rec,
+ struct socket_address *src,
+ enum wrepl_name_type new_type)
+{
+ struct nbtd_interface *iface = talloc_get_type(nbtsock->incoming.private_data,
+ struct nbtd_interface);
+ struct wins_server *winssrv = iface->nbtsrv->winssrv;
+ struct nbtd_wins_wack_state *s;
+ struct composite_context *c_req;
+ uint32_t ttl;
+
+ s = talloc_zero(nbtsock, struct nbtd_wins_wack_state);
+ if (s == NULL) goto failed;
+
+ /* package up the state variables for this wack request */
+ s->winssrv = winssrv;
+ s->nbtsock = nbtsock;
+ s->iface = iface;
+ s->request_packet = talloc_steal(s, packet);
+ s->rec = talloc_steal(s, rec);
+ s->reg_address = packet->additional[0].rdata.netbios.addresses[0].ipaddr;
+ s->new_type = new_type;
+ s->src = src;
+ if (talloc_reference(s, src) == NULL) goto failed;
+
+ s->io.in.nbtd_server = iface->nbtsrv;
+ s->io.in.nbt_port = lp_nbt_port(iface->nbtsrv->task->lp_ctx);
+ s->io.in.event_ctx = iface->nbtsrv->task->event_ctx;
+ s->io.in.name = rec->name;
+ s->io.in.num_addresses = winsdb_addr_list_length(rec->addresses);
+ s->io.in.addresses = winsdb_addr_string_list(s, rec->addresses);
+ if (s->io.in.addresses == NULL) goto failed;
+
+ DLIST_ADD_END(iface->wack_queue, s, struct nbtd_wins_wack_state *);
+
+ talloc_set_destructor(s, nbtd_wins_wack_state_destructor);
+
+ /*
+ * send a WACK to the client, specifying the maximum time it could
+ * take to check with the owner, plus some slack
+ */
+ ttl = 5 + 4 * winsdb_addr_list_length(rec->addresses);
+ nbtd_wack_reply(nbtsock, packet, src, ttl);
+
+ /*
+ * send the challenge to the old addresses
+ */
+ c_req = wins_challenge_send(s, &s->io);
+ if (c_req == NULL) goto failed;
+
+ c_req->async.fn = wack_wins_challenge_handler;
+ c_req->async.private_data = s;
+ return;
+
+failed:
+ talloc_free(s);
+ nbtd_name_registration_reply(nbtsock, packet, src, NBT_RCODE_SVR);