struct ctdb_takeover_arp {
struct ctdb_context *ctdb;
uint32_t count;
- struct sockaddr_in sin;
+ ctdb_sock_addr addr;
struct ctdb_tcp_array *tcparray;
struct ctdb_vnn *vnn;
};
struct ctdb_client_ip {
struct ctdb_client_ip *prev, *next;
struct ctdb_context *ctdb;
- struct sockaddr_in ip;
+ ctdb_sock_addr addr;
uint32_t client_id;
};
{
struct ctdb_takeover_arp *arp = talloc_get_type(private_data,
struct ctdb_takeover_arp);
- int i, s, ret;
+ int i, ret;
struct ctdb_tcp_array *tcparray;
-
- ret = ctdb_sys_send_arp(&arp->sin, arp->vnn->iface);
+ ret = ctdb_sys_send_arp(&arp->addr, arp->vnn->iface);
if (ret != 0) {
- DEBUG(0,(__location__ " sending of arp failed (%s)\n", strerror(errno)));
- }
-
- s = ctdb_sys_open_sending_socket();
- if (s == -1) {
- DEBUG(0,(__location__ " failed to open raw socket for sending tickles\n"));
- return;
+ DEBUG(DEBUG_CRIT,(__location__ " sending of arp failed (%s)\n", strerror(errno)));
}
tcparray = arp->tcparray;
if (tcparray) {
for (i=0;i<tcparray->num;i++) {
- DEBUG(2,("sending tcp tickle ack for %u->%s:%u\n",
- (unsigned)ntohs(tcparray->connections[i].daddr.sin_port),
- inet_ntoa(tcparray->connections[i].saddr.sin_addr),
- (unsigned)ntohs(tcparray->connections[i].saddr.sin_port)));
- ret = ctdb_sys_send_tcp(s, &tcparray->connections[i].saddr,
- &tcparray->connections[i].daddr, 0, 0, 0);
+ struct ctdb_tcp_connection *tcon;
+
+ tcon = &tcparray->connections[i];
+ DEBUG(DEBUG_INFO,("sending tcp tickle ack for %u->%s:%u\n",
+ (unsigned)ntohs(tcon->dst_addr.ip.sin_port),
+ ctdb_addr_to_str(&tcon->src_addr),
+ (unsigned)ntohs(tcon->src_addr.ip.sin_port)));
+ ret = ctdb_sys_send_tcp(
+ &tcon->src_addr,
+ &tcon->dst_addr,
+ 0, 0, 0);
if (ret != 0) {
- DEBUG(0,(__location__ " Failed to send tcp tickle ack for %s\n",
- inet_ntoa(tcparray->connections[i].saddr.sin_addr)));
+ DEBUG(DEBUG_CRIT,(__location__ " Failed to send tcp tickle ack for %s\n",
+ ctdb_addr_to_str(&tcon->src_addr)));
}
}
}
- close(s);
arp->count++;
if (arp->count == CTDB_ARP_REPEAT) {
}
event_add_timed(arp->ctdb->ev, arp->vnn->takeover_ctx,
- timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
+ timeval_current_ofs(CTDB_ARP_INTERVAL, 100000),
ctdb_control_send_arp, arp);
}
struct takeover_callback_state {
struct ctdb_req_control *c;
- struct sockaddr_in *sin;
+ ctdb_sock_addr *addr;
struct ctdb_vnn *vnn;
};
struct takeover_callback_state *state =
talloc_get_type(private_data, struct takeover_callback_state);
struct ctdb_takeover_arp *arp;
- char *ip = inet_ntoa(state->sin->sin_addr);
struct ctdb_tcp_array *tcparray;
- ctdb_start_monitoring(ctdb);
-
if (status != 0) {
- DEBUG(0,(__location__ " Failed to takeover IP %s on interface %s\n",
- ip, state->vnn->iface));
+ if (status == -ETIME) {
+ ctdb_ban_self(ctdb);
+ }
+ DEBUG(DEBUG_ERR,(__location__ " Failed to takeover IP %s on interface %s\n",
+ ctdb_addr_to_str(state->addr),
+ state->vnn->iface));
ctdb_request_control_reply(ctdb, state->c, NULL, status, NULL);
talloc_free(state);
return;
}
if (!state->vnn->takeover_ctx) {
- state->vnn->takeover_ctx = talloc_new(ctdb);
+ state->vnn->takeover_ctx = talloc_new(state->vnn);
if (!state->vnn->takeover_ctx) {
goto failed;
}
if (!arp) goto failed;
arp->ctdb = ctdb;
- arp->sin = *state->sin;
- arp->vnn = state->vnn;
+ arp->addr = *state->addr;
+ arp->vnn = state->vnn;
tcparray = state->vnn->tcp_array;
if (tcparray) {
Find the vnn of the node that has a public ip address
returns -1 if the address is not known as a public address
*/
-static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb, struct sockaddr_in ip)
+static struct ctdb_vnn *find_public_ip_vnn(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
{
struct ctdb_vnn *vnn;
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- if (ctdb_same_ip(&vnn->public_address, &ip)) {
+ if (ctdb_same_ip(&vnn->public_address, addr)) {
return vnn;
}
}
TDB_DATA indata,
bool *async_reply)
{
- TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
int ret;
struct takeover_callback_state *state;
struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
struct ctdb_vnn *vnn;
- bool have_ip, is_loopback;
- char *ifname = NULL;
/* update out vnn list */
- vnn = find_public_ip_vnn(ctdb, pip->sin);
+ vnn = find_public_ip_vnn(ctdb, &pip->addr);
if (vnn == NULL) {
- DEBUG(0,("takeoverip called for an ip '%s' that is not a public address\n",
- inet_ntoa(pip->sin.sin_addr)));
- talloc_free(tmp_ctx);
+ DEBUG(DEBUG_INFO,("takeoverip called for an ip '%s' that is not a public address\n",
+ ctdb_addr_to_str(&pip->addr)));
return 0;
}
vnn->pnn = pip->pnn;
/* if our kernel already has this IP, do nothing */
- have_ip = ctdb_sys_have_ip(pip->sin, &is_loopback, tmp_ctx, &ifname);
- /* if we have the ip and it is not set to a loopback address */
- if (have_ip && !is_loopback) {
- talloc_free(tmp_ctx);
+ if (ctdb_sys_have_ip(&pip->addr)) {
return 0;
}
- state = talloc(ctdb, struct takeover_callback_state);
+ state = talloc(vnn, struct takeover_callback_state);
CTDB_NO_MEMORY(ctdb, state);
state->c = talloc_steal(ctdb, c);
- state->sin = talloc(ctdb, struct sockaddr_in);
- CTDB_NO_MEMORY(ctdb, state->sin);
- *state->sin = pip->sin;
-
- state->vnn = vnn;
+ state->addr = talloc(ctdb, ctdb_sock_addr);
+ CTDB_NO_MEMORY(ctdb, state->addr);
- DEBUG(0,("Takeover of IP %s/%u on interface %s\n",
- inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
- vnn->iface));
+ *state->addr = pip->addr;
+ state->vnn = vnn;
- ctdb_stop_monitoring(ctdb);
+ DEBUG(DEBUG_NOTICE,("Takeover of IP %s/%u on interface %s\n",
+ ctdb_addr_to_str(&pip->addr),
+ vnn->public_netmask_bits,
+ vnn->iface));
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
state, takeover_ip_callback, state,
- "takeip %s %s %u",
+ false,
+ CTDB_EVENT_TAKE_IP,
+ "%s %s %u",
vnn->iface,
- inet_ntoa(pip->sin.sin_addr),
+ talloc_strdup(state, ctdb_addr_to_str(&pip->addr)),
vnn->public_netmask_bits);
+
if (ret != 0) {
- DEBUG(0,(__location__ " Failed to takeover IP %s on interface %s\n",
- inet_ntoa(pip->sin.sin_addr), vnn->iface));
- talloc_free(tmp_ctx);
+ DEBUG(DEBUG_ERR,(__location__ " Failed to takeover IP %s on interface %s\n",
+ ctdb_addr_to_str(&pip->addr),
+ vnn->iface));
talloc_free(state);
return -1;
}
/* tell ctdb_control.c that we will be replying asynchronously */
*async_reply = true;
- talloc_free(tmp_ctx);
return 0;
}
+/*
+ takeover an ip address old v4 style
+ */
+int32_t ctdb_control_takeover_ipv4(struct ctdb_context *ctdb,
+ struct ctdb_req_control *c,
+ TDB_DATA indata,
+ bool *async_reply)
+{
+ TDB_DATA data;
+
+ data.dsize = sizeof(struct ctdb_public_ip);
+ data.dptr = (uint8_t *)talloc_zero(c, struct ctdb_public_ip);
+ CTDB_NO_MEMORY(ctdb, data.dptr);
+
+ memcpy(data.dptr, indata.dptr, indata.dsize);
+ return ctdb_control_takeover_ip(ctdb, c, data, async_reply);
+}
+
/*
kill any clients that are registered with a IP that is being released
*/
-static void release_kill_clients(struct ctdb_context *ctdb, struct sockaddr_in in)
+static void release_kill_clients(struct ctdb_context *ctdb, ctdb_sock_addr *addr)
{
struct ctdb_client_ip *ip;
+ DEBUG(DEBUG_INFO,("release_kill_clients for ip %s\n",
+ ctdb_addr_to_str(addr)));
+
for (ip=ctdb->client_ip_list; ip; ip=ip->next) {
- if (ctdb_same_ip(&ip->ip, &in)) {
+ ctdb_sock_addr tmp_addr;
+
+ tmp_addr = ip->addr;
+ DEBUG(DEBUG_INFO,("checking for client %u with IP %s\n",
+ ip->client_id,
+ ctdb_addr_to_str(&ip->addr)));
+
+ if (ctdb_same_ip(&tmp_addr, addr)) {
struct ctdb_client *client = ctdb_reqid_find(ctdb,
ip->client_id,
struct ctdb_client);
+ DEBUG(DEBUG_INFO,("matched client %u with IP %s and pid %u\n",
+ ip->client_id,
+ ctdb_addr_to_str(&ip->addr),
+ client->pid));
+
if (client->pid != 0) {
- DEBUG(0,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
- (unsigned)client->pid, inet_ntoa(in.sin_addr),
- ip->client_id));
+ DEBUG(DEBUG_INFO,(__location__ " Killing client pid %u for IP %s on client_id %u\n",
+ (unsigned)client->pid,
+ ctdb_addr_to_str(addr),
+ ip->client_id));
kill(client->pid, SIGKILL);
}
}
{
struct takeover_callback_state *state =
talloc_get_type(private_data, struct takeover_callback_state);
- char *ip = inet_ntoa(state->sin->sin_addr);
TDB_DATA data;
- ctdb_start_monitoring(ctdb);
+ if (status == -ETIME) {
+ ctdb_ban_self(ctdb);
+ }
/* send a message to all clients of this node telling them
that the cluster has been reconfigured and they should
release any sockets on this IP */
- data.dptr = (uint8_t *)ip;
- data.dsize = strlen(ip)+1;
+ data.dptr = (uint8_t *)talloc_strdup(state, ctdb_addr_to_str(state->addr));
+ CTDB_NO_MEMORY_VOID(ctdb, data.dptr);
+ data.dsize = strlen((char *)data.dptr)+1;
+
+ DEBUG(DEBUG_INFO,(__location__ " sending RELEASE_IP for '%s'\n", data.dptr));
ctdb_daemon_send_message(ctdb, ctdb->pnn, CTDB_SRVID_RELEASE_IP, data);
/* kill clients that have registered with this IP */
- release_kill_clients(ctdb, *state->sin);
+ release_kill_clients(ctdb, state->addr);
/* the control succeeded */
ctdb_request_control_reply(ctdb, state->c, NULL, 0, NULL);
TDB_DATA indata,
bool *async_reply)
{
- TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
int ret;
struct takeover_callback_state *state;
struct ctdb_public_ip *pip = (struct ctdb_public_ip *)indata.dptr;
struct ctdb_vnn *vnn;
- bool have_ip, is_loopback;
- char *ifname = NULL;
/* update our vnn list */
- vnn = find_public_ip_vnn(ctdb, pip->sin);
+ vnn = find_public_ip_vnn(ctdb, &pip->addr);
if (vnn == NULL) {
- DEBUG(0,("releaseip called for an ip '%s' that is not a public address\n",
- inet_ntoa(pip->sin.sin_addr)));
- talloc_free(tmp_ctx);
+ DEBUG(DEBUG_INFO,("releaseip called for an ip '%s' that is not a public address\n",
+ ctdb_addr_to_str(&pip->addr)));
return 0;
}
vnn->pnn = pip->pnn;
- have_ip = ctdb_sys_have_ip(pip->sin, &is_loopback, tmp_ctx, &ifname);
- if ( (!have_ip) || is_loopback) {
- DEBUG(0,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
- inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
- vnn->iface));
- talloc_free(tmp_ctx);
- return 0;
- }
-
- DEBUG(0,("Release of IP %s/%u on interface %s\n",
- inet_ntoa(pip->sin.sin_addr), vnn->public_netmask_bits,
- vnn->iface));
-
/* stop any previous arps */
talloc_free(vnn->takeover_ctx);
vnn->takeover_ctx = NULL;
+ if (!ctdb_sys_have_ip(&pip->addr)) {
+ DEBUG(DEBUG_DEBUG,("Redundant release of IP %s/%u on interface %s (ip not held)\n",
+ ctdb_addr_to_str(&pip->addr),
+ vnn->public_netmask_bits,
+ vnn->iface));
+ return 0;
+ }
+
+ DEBUG(DEBUG_NOTICE,("Release of IP %s/%u on interface %s node:%u\n",
+ ctdb_addr_to_str(&pip->addr),
+ vnn->public_netmask_bits,
+ vnn->iface,
+ pip->pnn));
+
state = talloc(ctdb, struct takeover_callback_state);
CTDB_NO_MEMORY(ctdb, state);
state->c = talloc_steal(state, c);
- state->sin = talloc(state, struct sockaddr_in);
- CTDB_NO_MEMORY(ctdb, state->sin);
- *state->sin = pip->sin;
-
- state->vnn = vnn;
-
- ctdb_stop_monitoring(ctdb);
+ state->addr = talloc(state, ctdb_sock_addr);
+ CTDB_NO_MEMORY(ctdb, state->addr);
+ *state->addr = pip->addr;
+ state->vnn = vnn;
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
state, release_ip_callback, state,
- "releaseip %s %s %u",
+ false,
+ CTDB_EVENT_RELEASE_IP,
+ "%s %s %u",
vnn->iface,
- inet_ntoa(pip->sin.sin_addr),
+ talloc_strdup(state, ctdb_addr_to_str(&pip->addr)),
vnn->public_netmask_bits);
if (ret != 0) {
- DEBUG(0,(__location__ " Failed to release IP %s on interface %s\n",
- inet_ntoa(pip->sin.sin_addr), vnn->iface));
- talloc_free(tmp_ctx);
+ DEBUG(DEBUG_ERR,(__location__ " Failed to release IP %s on interface %s\n",
+ ctdb_addr_to_str(&pip->addr),
+ vnn->iface));
talloc_free(state);
return -1;
}
/* tell the control that we will be reply asynchronously */
*async_reply = true;
-
- talloc_free(tmp_ctx);
return 0;
}
+/*
+ release an ip address old v4 style
+ */
+int32_t ctdb_control_release_ipv4(struct ctdb_context *ctdb,
+ struct ctdb_req_control *c,
+ TDB_DATA indata,
+ bool *async_reply)
+{
+ TDB_DATA data;
+
+ data.dsize = sizeof(struct ctdb_public_ip);
+ data.dptr = (uint8_t *)talloc_zero(c, struct ctdb_public_ip);
+ CTDB_NO_MEMORY(ctdb, data.dptr);
+
+ memcpy(data.dptr, indata.dptr, indata.dsize);
+ return ctdb_control_release_ip(ctdb, c, data, async_reply);
+}
-static int add_public_address(struct ctdb_context *ctdb, struct sockaddr_in addr, unsigned mask, const char *iface)
+static int ctdb_add_public_address(struct ctdb_context *ctdb, ctdb_sock_addr *addr, unsigned mask, const char *iface)
{
struct ctdb_vnn *vnn;
/* Verify that we dont have an entry for this ip yet */
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- if (ctdb_same_sockaddr(&addr, &vnn->public_address)) {
- DEBUG(0,("Same ip '%s' specified multiple times in the public address list \n",
- inet_ntoa(addr.sin_addr)));
- exit(1);
+ if (ctdb_same_sockaddr(addr, &vnn->public_address)) {
+ DEBUG(DEBUG_CRIT,("Same ip '%s' specified multiple times in the public address list \n",
+ ctdb_addr_to_str(addr)));
+ return -1;
}
}
vnn = talloc_zero(ctdb, struct ctdb_vnn);
CTDB_NO_MEMORY_FATAL(ctdb, vnn);
vnn->iface = talloc_strdup(vnn, iface);
- vnn->public_address = addr;
+ CTDB_NO_MEMORY(ctdb, vnn->iface);
+ vnn->public_address = *addr;
vnn->public_netmask_bits = mask;
vnn->pnn = -1;
for (i=0;i<nlines;i++) {
unsigned mask;
- struct sockaddr_in addr;
- char ifacebuf[100];
+ ctdb_sock_addr addr;
+ const char *addrstr;
const char *iface;
- char *tok;
+ char *tok, *line;
- tok = strtok(lines[i], " \t");
- if (!tok || !parse_ip_mask(tok, &addr, &mask)) {
- DEBUG(0,("Badly formed line %u in public address list\n", i+1));
- talloc_free(lines);
- return -1;
+ line = lines[i];
+ while ((*line == ' ') || (*line == '\t')) {
+ line++;
+ }
+ if (*line == '#') {
+ continue;
}
+ if (strcmp(line, "") == 0) {
+ continue;
+ }
+ tok = strtok(line, " \t");
+ addrstr = tok;
tok = strtok(NULL, " \t");
if (tok == NULL) {
if (NULL == ctdb->default_public_interface) {
- DEBUG(0,("No default public interface and no interface specified at line %u of public address list\n",
+ DEBUG(DEBUG_CRIT,("No default public interface and no interface specified at line %u of public address list\n",
i+1));
talloc_free(lines);
return -1;
}
iface = ctdb->default_public_interface;
} else {
- iface = ifacebuf;
+ iface = tok;
}
- if (add_public_address(ctdb, addr, mask, iface)) {
- DEBUG(0,("Failed to add line %u to the public address list\n", i+1));
+ if (!addrstr || !parse_ip_mask(addrstr, iface, &addr, &mask)) {
+ DEBUG(DEBUG_CRIT,("Badly formed line %u in public address list\n", i+1));
+ talloc_free(lines);
+ return -1;
+ }
+ if (ctdb_add_public_address(ctdb, &addr, mask, iface)) {
+ DEBUG(DEBUG_CRIT,("Failed to add line %u to the public address list\n", i+1));
talloc_free(lines);
return -1;
}
struct ctdb_public_ip_list {
struct ctdb_public_ip_list *next;
uint32_t pnn;
- struct sockaddr_in sin;
+ ctdb_sock_addr addr;
};
}
for (i=0;i<public_ips->num;i++) {
- if (ip->sin.sin_addr.s_addr == public_ips->ips[i].sin.sin_addr.s_addr) {
+ if (ctdb_same_ip(&ip->addr, &public_ips->ips[i].addr)) {
/* yes, this node can serve this public ip */
return 0;
}
}
}
if (pnn == -1) {
- DEBUG(0,(__location__ " Could not find node to take over public address '%s'\n", inet_ntoa(ip->sin.sin_addr)));
+ DEBUG(DEBUG_WARNING,(__location__ " Could not find node to take over public address '%s'\n",
+ ctdb_addr_to_str(&ip->addr)));
+
return -1;
}
return 0;
}
-struct ctdb_public_ip_list *
-add_ip_to_merged_list(struct ctdb_context *ctdb,
- TALLOC_CTX *tmp_ctx,
- struct ctdb_public_ip_list *ip_list,
- struct ctdb_public_ip *ip)
+#define IP_KEYLEN 4
+static uint32_t *ip_key(ctdb_sock_addr *ip)
{
- struct ctdb_public_ip_list *tmp_ip;
+ static uint32_t key[IP_KEYLEN];
- /* do we already have this ip in our merged list ?*/
- for (tmp_ip=ip_list;tmp_ip;tmp_ip=tmp_ip->next) {
+ bzero(key, sizeof(key));
- /* we already have this public ip in the list */
- if (tmp_ip->sin.sin_addr.s_addr == ip->sin.sin_addr.s_addr) {
- return ip_list;
- }
+ switch (ip->sa.sa_family) {
+ case AF_INET:
+ key[3] = htonl(ip->ip.sin_addr.s_addr);
+ break;
+ case AF_INET6:
+ key[0] = htonl(ip->ip6.sin6_addr.s6_addr32[0]);
+ key[1] = htonl(ip->ip6.sin6_addr.s6_addr32[1]);
+ key[2] = htonl(ip->ip6.sin6_addr.s6_addr32[2]);
+ key[3] = htonl(ip->ip6.sin6_addr.s6_addr32[3]);
+ break;
+ default:
+ DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", ip->sa.sa_family));
+ return key;
}
- /* this is a new public ip, we must add it to the list */
- tmp_ip = talloc_zero(tmp_ctx, struct ctdb_public_ip_list);
- CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
- tmp_ip->pnn = ip->pnn;
- tmp_ip->sin = ip->sin;
- tmp_ip->next = ip_list;
+ return key;
+}
+
+static void *add_ip_callback(void *parm, void *data)
+{
+ return parm;
+}
+
+void getips_count_callback(void *param, void *data)
+{
+ struct ctdb_public_ip_list **ip_list = (struct ctdb_public_ip_list **)param;
+ struct ctdb_public_ip_list *new_ip = (struct ctdb_public_ip_list *)data;
- return tmp_ip;
+ new_ip->next = *ip_list;
+ *ip_list = new_ip;
}
-struct ctdb_public_ip_list *
-create_merged_ip_list(struct ctdb_context *ctdb, TALLOC_CTX *tmp_ctx)
+static struct ctdb_public_ip_list *
+create_merged_ip_list(struct ctdb_context *ctdb)
{
int i, j;
- struct ctdb_public_ip_list *ip_list = NULL;
+ struct ctdb_public_ip_list *ip_list;
struct ctdb_all_public_ips *public_ips;
+ if (ctdb->ip_tree != NULL) {
+ talloc_free(ctdb->ip_tree);
+ ctdb->ip_tree = NULL;
+ }
+ ctdb->ip_tree = trbt_create(ctdb, 0);
+
for (i=0;i<ctdb->num_nodes;i++) {
public_ips = ctdb->nodes[i]->public_ips;
+ if (ctdb->nodes[i]->flags & NODE_FLAGS_DELETED) {
+ continue;
+ }
+
/* there were no public ips for this node */
if (public_ips == NULL) {
continue;
}
for (j=0;j<public_ips->num;j++) {
- ip_list = add_ip_to_merged_list(ctdb, tmp_ctx,
- ip_list, &public_ips->ips[j]);
+ struct ctdb_public_ip_list *tmp_ip;
+
+ tmp_ip = talloc_zero(ctdb->ip_tree, struct ctdb_public_ip_list);
+ CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
+ tmp_ip->pnn = public_ips->ips[j].pnn;
+ tmp_ip->addr = public_ips->ips[j].addr;
+ tmp_ip->next = NULL;
+
+ trbt_insertarray32_callback(ctdb->ip_tree,
+ IP_KEYLEN, ip_key(&public_ips->ips[j].addr),
+ add_ip_callback,
+ tmp_ip);
}
}
+ ip_list = NULL;
+ trbt_traversearray32(ctdb->ip_tree, IP_KEYLEN, getips_count_callback, &ip_list);
+
return ip_list;
}
int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap)
{
int i, num_healthy, retries;
- int ret;
struct ctdb_public_ip ip;
+ struct ctdb_public_ipv4 ipv4;
uint32_t mask;
struct ctdb_public_ip_list *all_ips, *tmp_ip;
int maxnode, maxnum=0, minnode, minnum=0, num;
+ TDB_DATA data;
+ struct timeval timeout;
+ struct client_async_data *async_data;
+ struct ctdb_client_control_state *state;
TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
a full list of all public addresses that exist in the cluster.
Walk over all node structures and create a merged list of
all public addresses that exist in the cluster.
+
+ keep the tree of ips around as ctdb->ip_tree
+ */
+ all_ips = create_merged_ip_list(ctdb);
+
+ /* If we want deterministic ip allocations, i.e. that the ip addresses
+ will always be allocated the same way for a specific set of
+ available/unavailable nodes.
*/
- all_ips = create_merged_ip_list(ctdb, tmp_ctx);
+ if (1 == ctdb->tunable.deterministic_public_ips) {
+ DEBUG(DEBUG_NOTICE,("Deterministic IPs enabled. Resetting all ip allocations\n"));
+ for (i=0,tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next,i++) {
+ tmp_ip->pnn = i%nodemap->num;
+ }
+ }
/* mark all public addresses with a masked node as being served by
}
}
+ /* verify that the assigned nodes can serve that public ip
+ and set it to -1 if not
+ */
+ for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
+ if (tmp_ip->pnn == -1) {
+ continue;
+ }
+ if (can_node_serve_ip(ctdb, tmp_ip->pnn, tmp_ip) != 0) {
+ /* this node can not serve this ip. */
+ tmp_ip->pnn = -1;
+ }
+ }
+
/* now we must redistribute all public addresses with takeover node
-1 among the nodes available
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
if (tmp_ip->pnn == -1) {
if (find_takeover_node(ctdb, nodemap, mask, tmp_ip, all_ips)) {
- DEBUG(0,("Failed to find node to cover ip %s\n", inet_ntoa(tmp_ip->sin.sin_addr)));
+ DEBUG(DEBUG_WARNING,("Failed to find node to cover ip %s\n",
+ ctdb_addr_to_str(&tmp_ip->addr)));
}
}
}
+ /* If we dont want ips to fail back after a node becomes healthy
+ again, we wont even try to reallocat the ip addresses so that
+ they are evenly spread out.
+ This can NOT be used at the same time as DeterministicIPs !
+ */
+ if (1 == ctdb->tunable.no_ip_failback) {
+ if (1 == ctdb->tunable.deterministic_public_ips) {
+ DEBUG(DEBUG_ERR, ("ERROR: You can not use 'DeterministicIPs' and 'NoIPFailback' at the same time\n"));
+ }
+ goto finished;
+ }
+
/* now, try to make sure the ip adresses are evenly distributed
across the node.
}
}
if (maxnode == -1) {
- DEBUG(0,(__location__ " Could not find maxnode. May not be able to server ip '%s'\n", inet_ntoa(tmp_ip->sin.sin_addr)));
+ DEBUG(DEBUG_WARNING,(__location__ " Could not find maxnode. May not be able to serve ip '%s'\n",
+ ctdb_addr_to_str(&tmp_ip->addr)));
+
+ continue;
+ }
+
+ /* If we want deterministic IPs then dont try to reallocate
+ them to spread out the load.
+ */
+ if (1 == ctdb->tunable.deterministic_public_ips) {
continue;
}
}
+ /* finished distributing the public addresses, now just send the
+ info out to the nodes
+ */
+finished:
/* at this point ->pnn is the node which will own each IP
or -1 if there is no node that can cover this ip
/* now tell all nodes to delete any alias that they should not
have. This will be a NOOP on nodes that don't currently
hold the given alias */
+ async_data = talloc_zero(tmp_ctx, struct client_async_data);
+ CTDB_NO_MEMORY_FATAL(ctdb, async_data);
+
for (i=0;i<nodemap->num;i++) {
/* don't talk to unconnected nodes, but do talk to banned nodes */
if (nodemap->nodes[i].flags & NODE_FLAGS_DISCONNECTED) {
*/
continue;
}
- ip.pnn = tmp_ip->pnn;
- ip.sin.sin_family = AF_INET;
- ip.sin.sin_addr = tmp_ip->sin.sin_addr;
+ if (tmp_ip->addr.sa.sa_family == AF_INET) {
+ ipv4.pnn = tmp_ip->pnn;
+ ipv4.sin = tmp_ip->addr.ip;
+
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ipv4);
+ data.dptr = (uint8_t *)&ipv4;
+ state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
+ 0, CTDB_CONTROL_RELEASE_IPv4, 0,
+ data, async_data,
+ &timeout, NULL);
+ } else {
+ ip.pnn = tmp_ip->pnn;
+ ip.addr = tmp_ip->addr;
+
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ip);
+ data.dptr = (uint8_t *)&ip;
+ state = ctdb_control_send(ctdb, nodemap->nodes[i].pnn,
+ 0, CTDB_CONTROL_RELEASE_IP, 0,
+ data, async_data,
+ &timeout, NULL);
+ }
- ret = ctdb_ctrl_release_ip(ctdb, TAKEOVER_TIMEOUT(),
- nodemap->nodes[i].pnn,
- &ip);
- if (ret != 0) {
- DEBUG(0,("Failed to tell vnn %u to release IP %s\n",
- nodemap->nodes[i].pnn,
- inet_ntoa(tmp_ip->sin.sin_addr)));
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to call async control CTDB_CONTROL_RELEASE_IP to node %u\n", nodemap->nodes[i].pnn));
talloc_free(tmp_ctx);
return -1;
}
+
+ ctdb_client_async_add(async_data, state);
}
}
+ if (ctdb_client_async_wait(ctdb, async_data) != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_RELEASE_IP failed\n"));
+ talloc_free(tmp_ctx);
+ return -1;
+ }
+ talloc_free(async_data);
/* tell all nodes to get their own IPs */
+ async_data = talloc_zero(tmp_ctx, struct client_async_data);
+ CTDB_NO_MEMORY_FATAL(ctdb, async_data);
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
if (tmp_ip->pnn == -1) {
/* this IP won't be taken over */
continue;
}
- ip.pnn = tmp_ip->pnn;
- ip.sin.sin_family = AF_INET;
- ip.sin.sin_addr = tmp_ip->sin.sin_addr;
- ret = ctdb_ctrl_takeover_ip(ctdb, TAKEOVER_TIMEOUT(),
- tmp_ip->pnn,
- &ip);
- if (ret != 0) {
- DEBUG(0,("Failed asking vnn %u to take over IP %s\n",
- tmp_ip->pnn,
- inet_ntoa(tmp_ip->sin.sin_addr)));
+ if (tmp_ip->addr.sa.sa_family == AF_INET) {
+ ipv4.pnn = tmp_ip->pnn;
+ ipv4.sin = tmp_ip->addr.ip;
+
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ipv4);
+ data.dptr = (uint8_t *)&ipv4;
+ state = ctdb_control_send(ctdb, tmp_ip->pnn,
+ 0, CTDB_CONTROL_TAKEOVER_IPv4, 0,
+ data, async_data,
+ &timeout, NULL);
+ } else {
+ ip.pnn = tmp_ip->pnn;
+ ip.addr = tmp_ip->addr;
+
+ timeout = TAKEOVER_TIMEOUT();
+ data.dsize = sizeof(ip);
+ data.dptr = (uint8_t *)&ip;
+ state = ctdb_control_send(ctdb, tmp_ip->pnn,
+ 0, CTDB_CONTROL_TAKEOVER_IP, 0,
+ data, async_data,
+ &timeout, NULL);
+ }
+ if (state == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to call async control CTDB_CONTROL_TAKEOVER_IP to node %u\n", tmp_ip->pnn));
talloc_free(tmp_ctx);
return -1;
}
+
+ ctdb_client_async_add(async_data, state);
+ }
+ if (ctdb_client_async_wait(ctdb, async_data) != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " Async control CTDB_CONTROL_TAKEOVER_IP failed\n"));
+ talloc_free(tmp_ctx);
+ return -1;
}
talloc_free(tmp_ctx);
*/
static int ctdb_client_ip_destructor(struct ctdb_client_ip *ip)
{
+ DEBUG(DEBUG_DEBUG,("destroying client tcp for %s:%u (client_id %u)\n",
+ ctdb_addr_to_str(&ip->addr),
+ ntohs(ip->addr.ip.sin_port),
+ ip->client_id));
+
DLIST_REMOVE(ip->ctdb->client_ip_list, ip);
return 0;
}
/*
called by a client to inform us of a TCP connection that it is managing
that should tickled with an ACK when IP takeover is done
+ we handle both the old ipv4 style of packets as well as the new ipv4/6
+ pdus.
*/
int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
TDB_DATA indata)
{
struct ctdb_client *client = ctdb_reqid_find(ctdb, client_id, struct ctdb_client);
- struct ctdb_control_tcp *p = (struct ctdb_control_tcp *)indata.dptr;
+ struct ctdb_control_tcp *old_addr = NULL;
+ struct ctdb_control_tcp_addr new_addr;
+ struct ctdb_control_tcp_addr *tcp_sock = NULL;
struct ctdb_tcp_list *tcp;
struct ctdb_control_tcp_vnn t;
int ret;
TDB_DATA data;
struct ctdb_client_ip *ip;
struct ctdb_vnn *vnn;
+ ctdb_sock_addr addr;
+
+ switch (indata.dsize) {
+ case sizeof(struct ctdb_control_tcp):
+ old_addr = (struct ctdb_control_tcp *)indata.dptr;
+ ZERO_STRUCT(new_addr);
+ tcp_sock = &new_addr;
+ tcp_sock->src.ip = old_addr->src;
+ tcp_sock->dest.ip = old_addr->dest;
+ break;
+ case sizeof(struct ctdb_control_tcp_addr):
+ tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
+ break;
+ default:
+ DEBUG(DEBUG_ERR,(__location__ " Invalid data structure passed "
+ "to ctdb_control_tcp_client. size was %d but "
+ "only allowed sizes are %lu and %lu\n",
+ (int)indata.dsize,
+ (long unsigned)sizeof(struct ctdb_control_tcp),
+ (long unsigned)sizeof(struct ctdb_control_tcp_addr)));
+ return -1;
+ }
- vnn = find_public_ip_vnn(ctdb, p->dest);
+ addr = tcp_sock->src;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->src);
+ addr = tcp_sock->dest;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->dest);
+
+ ZERO_STRUCT(addr);
+ memcpy(&addr, &tcp_sock->dest, sizeof(addr));
+ vnn = find_public_ip_vnn(ctdb, &addr);
if (vnn == NULL) {
- DEBUG(3,("Could not add client IP %s. This is not a public address.\n", inet_ntoa(p->dest.sin_addr)));
+ switch (addr.sa.sa_family) {
+ case AF_INET:
+ if (ntohl(addr.ip.sin_addr.s_addr) != INADDR_LOOPBACK) {
+ DEBUG(DEBUG_ERR,("Could not add client IP %s. This is not a public address.\n",
+ ctdb_addr_to_str(&addr)));
+ }
+ break;
+ case AF_INET6:
+ DEBUG(DEBUG_ERR,("Could not add client IP %s. This is not a public ipv6 address.\n",
+ ctdb_addr_to_str(&addr)));
+ break;
+ default:
+ DEBUG(DEBUG_ERR,(__location__ " Unknown family type %d\n", addr.sa.sa_family));
+ }
+
return 0;
}
+ if (vnn->pnn != ctdb->pnn) {
+ DEBUG(DEBUG_ERR,("Attempt to register tcp client for IP %s we don't hold - failing (client_id %u pid %u)\n",
+ ctdb_addr_to_str(&addr),
+ client_id, client->pid));
+ /* failing this call will tell smbd to die */
+ return -1;
+ }
+
ip = talloc(client, struct ctdb_client_ip);
CTDB_NO_MEMORY(ctdb, ip);
- ip->ctdb = ctdb;
- ip->ip = p->dest;
+ ip->ctdb = ctdb;
+ ip->addr = addr;
ip->client_id = client_id;
talloc_set_destructor(ip, ctdb_client_ip_destructor);
DLIST_ADD(ctdb->client_ip_list, ip);
tcp = talloc(client, struct ctdb_tcp_list);
CTDB_NO_MEMORY(ctdb, tcp);
- tcp->connection.saddr = p->src;
- tcp->connection.daddr = p->dest;
+ tcp->connection.src_addr = tcp_sock->src;
+ tcp->connection.dst_addr = tcp_sock->dest;
DLIST_ADD(client->tcp_list, tcp);
- t.src = p->src;
- t.dest = p->dest;
+ t.src = tcp_sock->src;
+ t.dest = tcp_sock->dest;
data.dptr = (uint8_t *)&t;
data.dsize = sizeof(t);
- DEBUG(2,("registered tcp client for %u->%s:%u\n",
- (unsigned)ntohs(p->dest.sin_port),
- inet_ntoa(p->src.sin_addr),
- (unsigned)ntohs(p->src.sin_port)));
+ switch (addr.sa.sa_family) {
+ case AF_INET:
+ DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
+ (unsigned)ntohs(tcp_sock->dest.ip.sin_port),
+ ctdb_addr_to_str(&tcp_sock->src),
+ (unsigned)ntohs(tcp_sock->src.ip.sin_port), client_id, client->pid));
+ break;
+ case AF_INET6:
+ DEBUG(DEBUG_INFO,("registered tcp client for %u->%s:%u (client_id %u pid %u)\n",
+ (unsigned)ntohs(tcp_sock->dest.ip6.sin6_port),
+ ctdb_addr_to_str(&tcp_sock->src),
+ (unsigned)ntohs(tcp_sock->src.ip6.sin6_port), client_id, client->pid));
+ break;
+ default:
+ DEBUG(DEBUG_ERR,(__location__ " Unknown family %d\n", addr.sa.sa_family));
+ }
+
/* tell all nodes about this tcp connection */
ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_CONNECTED, 0,
CTDB_CONTROL_TCP_ADD,
0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
if (ret != 0) {
- DEBUG(0,(__location__ " Failed to send CTDB_CONTROL_TCP_ADD\n"));
+ DEBUG(DEBUG_ERR,(__location__ " Failed to send CTDB_CONTROL_TCP_ADD\n"));
return -1;
}
return 0;
}
-/*
- see if two sockaddr_in are the same
- */
-static bool same_sockaddr_in(struct sockaddr_in *in1, struct sockaddr_in *in2)
-{
- return in1->sin_family == in2->sin_family &&
- in1->sin_port == in2->sin_port &&
- in1->sin_addr.s_addr == in2->sin_addr.s_addr;
-}
-
/*
find a tcp address on a list
*/
}
for (i=0;i<array->num;i++) {
- if (same_sockaddr_in(&array->connections[i].saddr, &tcp->saddr) &&
- same_sockaddr_in(&array->connections[i].daddr, &tcp->daddr)) {
+ if (ctdb_same_sockaddr(&array->connections[i].src_addr, &tcp->src_addr) &&
+ ctdb_same_sockaddr(&array->connections[i].dst_addr, &tcp->dst_addr)) {
return &array->connections[i];
}
}
struct ctdb_tcp_connection tcp;
struct ctdb_vnn *vnn;
- vnn = find_public_ip_vnn(ctdb, p->dest);
+ vnn = find_public_ip_vnn(ctdb, &p->dest);
if (vnn == NULL) {
- DEBUG(0,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
- inet_ntoa(p->dest.sin_addr)));
- return-1;
+ DEBUG(DEBUG_INFO,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
+ ctdb_addr_to_str(&p->dest)));
+
+ return -1;
}
tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_tcp_connection));
CTDB_NO_MEMORY(ctdb, tcparray->connections);
- tcparray->connections[tcparray->num].saddr = p->src;
- tcparray->connections[tcparray->num].daddr = p->dest;
+ tcparray->connections[tcparray->num].src_addr = p->src;
+ tcparray->connections[tcparray->num].dst_addr = p->dest;
tcparray->num++;
return 0;
}
/* Do we already have this tickle ?*/
- tcp.saddr = p->src;
- tcp.daddr = p->dest;
+ tcp.src_addr = p->src;
+ tcp.dst_addr = p->dest;
if (ctdb_tcp_find(vnn->tcp_array, &tcp) != NULL) {
- DEBUG(4,("Already had tickle info for %s:%u for vnn:%u\n",
- inet_ntoa(tcp.daddr.sin_addr),
- ntohs(tcp.daddr.sin_port),
- vnn->pnn));
+ DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n",
+ ctdb_addr_to_str(&tcp.dst_addr),
+ ntohs(tcp.dst_addr.ip.sin_port),
+ vnn->pnn));
return 0;
}
CTDB_NO_MEMORY(ctdb, tcparray->connections);
vnn->tcp_array = tcparray;
- tcparray->connections[tcparray->num].saddr = p->src;
- tcparray->connections[tcparray->num].daddr = p->dest;
+ tcparray->connections[tcparray->num].src_addr = p->src;
+ tcparray->connections[tcparray->num].dst_addr = p->dest;
tcparray->num++;
- DEBUG(2,("Added tickle info for %s:%u from vnn %u\n",
- inet_ntoa(tcp.daddr.sin_addr),
- ntohs(tcp.daddr.sin_port),
- vnn->pnn));
+ DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n",
+ ctdb_addr_to_str(&tcp.dst_addr),
+ ntohs(tcp.dst_addr.ip.sin_port),
+ vnn->pnn));
return 0;
}
static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tcp_connection *conn)
{
struct ctdb_tcp_connection *tcpp;
- struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, conn->daddr);
+ struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst_addr);
if (vnn == NULL) {
- DEBUG(0,(__location__ " unable to find public address %s\n", inet_ntoa(conn->daddr.sin_addr)));
+ DEBUG(DEBUG_ERR,(__location__ " unable to find public address %s\n",
+ ctdb_addr_to_str(&conn->dst_addr)));
return;
}
and we dont need to do anything
*/
if (vnn->tcp_array == NULL) {
- DEBUG(2,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
- inet_ntoa(conn->daddr.sin_addr),
- ntohs(conn->daddr.sin_port)));
+ DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
+ ctdb_addr_to_str(&conn->dst_addr),
+ ntohs(conn->dst_addr.ip.sin_port)));
return;
}
*/
tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
if (tcpp == NULL) {
- DEBUG(2,("Trying to remove tickle that doesnt exist %s:%u\n",
- inet_ntoa(conn->daddr.sin_addr),
- ntohs(conn->daddr.sin_port)));
+ DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n",
+ ctdb_addr_to_str(&conn->dst_addr),
+ ntohs(conn->dst_addr.ip.sin_port)));
return;
}
vnn->tcp_update_needed = true;
- DEBUG(2,("Removed tickle info for %s:%u\n",
- inet_ntoa(conn->saddr.sin_addr),
- ntohs(conn->saddr.sin_port)));
+ DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n",
+ ctdb_addr_to_str(&conn->src_addr),
+ ntohs(conn->src_addr.ip.sin_port)));
}
void ctdb_release_all_ips(struct ctdb_context *ctdb)
{
struct ctdb_vnn *vnn;
- TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
- bool have_ip, is_loopback;
- char *ifname = NULL;
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- have_ip = ctdb_sys_have_ip(vnn->public_address, &is_loopback, tmp_ctx, &ifname);
- if (have_ip && !is_loopback) {
- ctdb_event_script(ctdb, "releaseip %s %s %u",
- vnn->iface,
- inet_ntoa(vnn->public_address.sin_addr),
- vnn->public_netmask_bits);
- release_kill_clients(ctdb, vnn->public_address);
+ if (!ctdb_sys_have_ip(&vnn->public_address)) {
+ continue;
}
+ if (vnn->pnn == ctdb->pnn) {
+ vnn->pnn = -1;
+ }
+ ctdb_event_script_args(ctdb, CTDB_EVENT_RELEASE_IP, "%s %s %u",
+ vnn->iface,
+ talloc_strdup(ctdb, ctdb_addr_to_str(&vnn->public_address)),
+ vnn->public_netmask_bits);
+ release_kill_clients(ctdb, &vnn->public_address);
}
- talloc_free(tmp_ctx);
}
ips->num = num;
i = 0;
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
- ips->ips[i].pnn = vnn->pnn;
- ips->ips[i].sin = vnn->public_address;
+ ips->ips[i].pnn = vnn->pnn;
+ ips->ips[i].addr = vnn->public_address;
i++;
}
}
+/*
+ get list of public IPs, old ipv4 style. only returns ipv4 addresses
+ */
+int32_t ctdb_control_get_public_ipsv4(struct ctdb_context *ctdb,
+ struct ctdb_req_control *c, TDB_DATA *outdata)
+{
+ int i, num, len;
+ struct ctdb_all_public_ipsv4 *ips;
+ struct ctdb_vnn *vnn;
+
+ /* count how many public ip structures we have */
+ num = 0;
+ for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+ if (vnn->public_address.sa.sa_family != AF_INET) {
+ continue;
+ }
+ num++;
+ }
+
+ len = offsetof(struct ctdb_all_public_ipsv4, ips) +
+ num*sizeof(struct ctdb_public_ipv4);
+ ips = talloc_zero_size(outdata, len);
+ CTDB_NO_MEMORY(ctdb, ips);
+
+ outdata->dsize = len;
+ outdata->dptr = (uint8_t *)ips;
+
+ ips->num = num;
+ i = 0;
+ for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+ if (vnn->public_address.sa.sa_family != AF_INET) {
+ continue;
+ }
+ ips->ips[i].pnn = vnn->pnn;
+ ips->ips[i].sin = vnn->public_address.ip;
+ i++;
+ }
+
+ return 0;
+}
+
/*
structure containing the listening socket and the list of tcp connections
struct ctdb_vnn *vnn;
struct ctdb_context *ctdb;
int capture_fd;
- int sending_fd;
struct fd_event *fde;
trbt_tree_t *connections;
void *private_data;
a tcp connection that is to be killed
*/
struct ctdb_killtcp_con {
- struct sockaddr_in src;
- struct sockaddr_in dst;
+ ctdb_sock_addr src_addr;
+ ctdb_sock_addr dst_addr;
int count;
struct ctdb_kill_tcp *killtcp;
};
this key is used to insert and lookup matching socketpairs that are
to be tickled and RST
*/
-#define KILLTCP_KEYLEN 4
-static uint32_t *killtcp_key(struct sockaddr_in *src, struct sockaddr_in *dst)
+#define KILLTCP_KEYLEN 10
+static uint32_t *killtcp_key(ctdb_sock_addr *src, ctdb_sock_addr *dst)
{
static uint32_t key[KILLTCP_KEYLEN];
- key[0] = dst->sin_addr.s_addr;
- key[1] = src->sin_addr.s_addr;
- key[2] = dst->sin_port;
- key[3] = src->sin_port;
+ bzero(key, sizeof(key));
+
+ if (src->sa.sa_family != dst->sa.sa_family) {
+ DEBUG(DEBUG_ERR, (__location__ " ERROR, different families passed :%u vs %u\n", src->sa.sa_family, dst->sa.sa_family));
+ return key;
+ }
+
+ switch (src->sa.sa_family) {
+ case AF_INET:
+ key[0] = dst->ip.sin_addr.s_addr;
+ key[1] = src->ip.sin_addr.s_addr;
+ key[2] = dst->ip.sin_port;
+ key[3] = src->ip.sin_port;
+ break;
+ case AF_INET6:
+ key[0] = dst->ip6.sin6_addr.s6_addr32[3];
+ key[1] = src->ip6.sin6_addr.s6_addr32[3];
+ key[2] = dst->ip6.sin6_addr.s6_addr32[2];
+ key[3] = src->ip6.sin6_addr.s6_addr32[2];
+ key[4] = dst->ip6.sin6_addr.s6_addr32[1];
+ key[5] = src->ip6.sin6_addr.s6_addr32[1];
+ key[6] = dst->ip6.sin6_addr.s6_addr32[0];
+ key[7] = src->ip6.sin6_addr.s6_addr32[0];
+ key[8] = dst->ip6.sin6_port;
+ key[9] = src->ip6.sin6_port;
+ break;
+ default:
+ DEBUG(DEBUG_ERR, (__location__ " ERROR, unknown family passed :%u\n", src->sa.sa_family));
+ return key;
+ }
return key;
}
{
struct ctdb_kill_tcp *killtcp = talloc_get_type(private_data, struct ctdb_kill_tcp);
struct ctdb_killtcp_con *con;
- struct sockaddr_in src, dst;
+ ctdb_sock_addr src, dst;
uint32_t ack_seq, seq;
if (!(flags & EVENT_FD_READ)) {
/* This one has been tickled !
now reset him and remove him from the list.
*/
- DEBUG(1, ("sending a tcp reset to kill connection :%d -> %s:%d\n", ntohs(con->dst.sin_port), inet_ntoa(con->src.sin_addr), ntohs(con->src.sin_port)));
+ DEBUG(DEBUG_INFO, ("sending a tcp reset to kill connection :%d -> %s:%d\n",
+ ntohs(con->dst_addr.ip.sin_port),
+ ctdb_addr_to_str(&con->src_addr),
+ ntohs(con->src_addr.ip.sin_port)));
- ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst,
- &con->src, ack_seq, seq, 1);
+ ctdb_sys_send_tcp(&con->dst_addr, &con->src_addr, ack_seq, seq, 1);
talloc_free(con);
}
static void tickle_connection_traverse(void *param, void *data)
{
struct ctdb_killtcp_con *con = talloc_get_type(data, struct ctdb_killtcp_con);
- struct ctdb_kill_tcp *killtcp = talloc_get_type(param, struct ctdb_kill_tcp);
/* have tried too many times, just give up */
if (con->count >= 5) {
/* othervise, try tickling it again */
con->count++;
- ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst, &con->src, 0, 0, 0);
+ ctdb_sys_send_tcp(
+ (ctdb_sock_addr *)&con->dst_addr,
+ (ctdb_sock_addr *)&con->src_addr,
+ 0, 0, 0);
}
/* loop over all connections sending tickle ACKs */
- trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, killtcp);
+ trbt_traversearray32(killtcp->connections, KILLTCP_KEYLEN, tickle_connection_traverse, NULL);
/* If there are no more connections to kill we can remove the
*/
static int ctdb_killtcp_destructor(struct ctdb_kill_tcp *killtcp)
{
- if (killtcp->sending_fd != -1) {
- close(killtcp->sending_fd);
- killtcp->sending_fd = -1;
- }
killtcp->vnn->killtcp = NULL;
return 0;
}
add a tcp socket to the list of connections we want to RST
*/
static int ctdb_killtcp_add_connection(struct ctdb_context *ctdb,
- struct sockaddr_in *src, struct sockaddr_in *dst)
+ ctdb_sock_addr *s,
+ ctdb_sock_addr *d)
{
+ ctdb_sock_addr src, dst;
struct ctdb_kill_tcp *killtcp;
struct ctdb_killtcp_con *con;
struct ctdb_vnn *vnn;
- vnn = find_public_ip_vnn(ctdb, *dst);
+ ctdb_canonicalize_ip(s, &src);
+ ctdb_canonicalize_ip(d, &dst);
+
+ vnn = find_public_ip_vnn(ctdb, &dst);
+ if (vnn == NULL) {
+ vnn = find_public_ip_vnn(ctdb, &src);
+ }
if (vnn == NULL) {
- vnn = find_public_ip_vnn(ctdb, *src);
+ /* if it is not a public ip it could be our 'single ip' */
+ if (ctdb->single_ip_vnn) {
+ if (ctdb_same_ip(&ctdb->single_ip_vnn->public_address, &dst)) {
+ vnn = ctdb->single_ip_vnn;
+ }
+ }
}
if (vnn == NULL) {
- DEBUG(0,(__location__ " Could not killtcp, not a public address\n"));
+ DEBUG(DEBUG_ERR,(__location__ " Could not killtcp, not a public address\n"));
return -1;
}
killtcp->vnn = vnn;
killtcp->ctdb = ctdb;
killtcp->capture_fd = -1;
- killtcp->sending_fd = -1;
killtcp->connections = trbt_create(killtcp, 0);
vnn->killtcp = killtcp;
*/
con = talloc(killtcp, struct ctdb_killtcp_con);
CTDB_NO_MEMORY(ctdb, con);
- con->src = *src;
- con->dst = *dst;
- con->count = 0;
- con->killtcp = killtcp;
+ con->src_addr = src;
+ con->dst_addr = dst;
+ con->count = 0;
+ con->killtcp = killtcp;
trbt_insertarray32_callback(killtcp->connections,
- KILLTCP_KEYLEN, killtcp_key(&con->dst, &con->src),
+ KILLTCP_KEYLEN, killtcp_key(&con->dst_addr, &con->src_addr),
add_killtcp_callback, con);
- /*
- If we dont have a socket to send from yet we must create it
- */
- if (killtcp->sending_fd == -1) {
- killtcp->sending_fd = ctdb_sys_open_sending_socket();
- if (killtcp->sending_fd == -1) {
- DEBUG(0,(__location__ " Failed to open sending socket for killtcp\n"));
- goto failed;
- }
- }
-
/*
If we dont have a socket to listen on yet we must create it
*/
if (killtcp->capture_fd == -1) {
killtcp->capture_fd = ctdb_sys_open_capture_socket(vnn->iface, &killtcp->private_data);
if (killtcp->capture_fd == -1) {
- DEBUG(0,(__location__ " Failed to open capturing socket for killtcp\n"));
+ DEBUG(DEBUG_CRIT,(__location__ " Failed to open capturing socket for killtcp\n"));
goto failed;
}
}
}
/* tickle him once now */
- ctdb_sys_send_tcp(killtcp->sending_fd, &con->dst, &con->src, 0, 0, 0);
+ ctdb_sys_send_tcp(
+ &con->dst_addr,
+ &con->src_addr,
+ 0, 0, 0);
return 0;
{
struct ctdb_control_killtcp *killtcp = (struct ctdb_control_killtcp *)indata.dptr;
- return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
+ return ctdb_killtcp_add_connection(ctdb, &killtcp->src_addr, &killtcp->dst_addr);
}
/*
*/
if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
tickles.connections)) {
- DEBUG(0,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
+ DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
return -1;
}
tickles.connections)
+ sizeof(struct ctdb_tcp_connection)
* list->tickles.num) {
- DEBUG(0,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
+ DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
return -1;
}
- vnn = find_public_ip_vnn(ctdb, list->ip);
+ vnn = find_public_ip_vnn(ctdb, &list->addr);
if (vnn == NULL) {
- DEBUG(0,(__location__ " Could not set tcp tickle list, '%s' is not a public address\n",
- inet_ntoa(list->ip.sin_addr)));
+ DEBUG(DEBUG_INFO,(__location__ " Could not set tcp tickle list, '%s' is not a public address\n",
+ ctdb_addr_to_str(&list->addr)));
+
return 1;
}
*/
int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
{
- struct sockaddr_in *ip = (struct sockaddr_in *)indata.dptr;
+ ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
struct ctdb_control_tcp_tickle_list *list;
struct ctdb_tcp_array *tcparray;
int num;
struct ctdb_vnn *vnn;
- vnn = find_public_ip_vnn(ctdb, *ip);
+ vnn = find_public_ip_vnn(ctdb, addr);
if (vnn == NULL) {
- DEBUG(0,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
- inet_ntoa(ip->sin_addr)));
+ DEBUG(DEBUG_ERR,(__location__ " Could not get tcp tickle list, '%s' is not a public address\n",
+ ctdb_addr_to_str(addr)));
+
return 1;
}
CTDB_NO_MEMORY(ctdb, outdata->dptr);
list = (struct ctdb_control_tcp_tickle_list *)outdata->dptr;
- list->ip = *ip;
+ list->addr = *addr;
list->tickles.num = num;
if (num) {
memcpy(&list->tickles.connections[0], tcparray->connections,
*/
static int ctdb_ctrl_set_tcp_tickles(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode,
- struct sockaddr_in *ip,
+ ctdb_sock_addr *addr,
struct ctdb_tcp_array *tcparray)
{
int ret, num;
CTDB_NO_MEMORY(ctdb, data.dptr);
list = (struct ctdb_control_tcp_tickle_list *)data.dptr;
- list->ip = *ip;
+ list->addr = *addr;
list->tickles.num = num;
if (tcparray) {
memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num);
CTDB_CONTROL_SET_TCP_TICKLE_LIST,
0, CTDB_CTRL_FLAG_NOREPLY, data, NULL, NULL);
if (ret != 0) {
- DEBUG(0,(__location__ " ctdb_control for set tcp tickles failed\n"));
+ DEBUG(DEBUG_ERR,(__location__ " ctdb_control for set tcp tickles failed\n"));
return -1;
}
&vnn->public_address,
vnn->tcp_array);
if (ret != 0) {
- DEBUG(0,("Failed to send the tickle update for public address %s\n",
- inet_ntoa(vnn->public_address.sin_addr)));
+ DEBUG(DEBUG_ERR,("Failed to send the tickle update for public address %s\n",
+ ctdb_addr_to_str(&vnn->public_address)));
}
}
timeval_current_ofs(ctdb->tunable.tickle_update_interval, 0),
ctdb_update_tcp_tickles, ctdb);
}
+
+
+
+
+struct control_gratious_arp {
+ struct ctdb_context *ctdb;
+ ctdb_sock_addr addr;
+ const char *iface;
+ int count;
+};
+
+/*
+ send a control_gratuitous arp
+ */
+static void send_gratious_arp(struct event_context *ev, struct timed_event *te,
+ struct timeval t, void *private_data)
+{
+ int ret;
+ struct control_gratious_arp *arp = talloc_get_type(private_data,
+ struct control_gratious_arp);
+
+ ret = ctdb_sys_send_arp(&arp->addr, arp->iface);
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " sending of gratious arp failed (%s)\n", strerror(errno)));
+ }
+
+
+ arp->count++;
+ if (arp->count == CTDB_ARP_REPEAT) {
+ talloc_free(arp);
+ return;
+ }
+
+ event_add_timed(arp->ctdb->ev, arp,
+ timeval_current_ofs(CTDB_ARP_INTERVAL, 0),
+ send_gratious_arp, arp);
+}
+
+
+/*
+ send a gratious arp
+ */
+int32_t ctdb_control_send_gratious_arp(struct ctdb_context *ctdb, TDB_DATA indata)
+{
+ struct ctdb_control_gratious_arp *gratious_arp = (struct ctdb_control_gratious_arp *)indata.dptr;
+ struct control_gratious_arp *arp;
+
+ /* verify the size of indata */
+ if (indata.dsize < offsetof(struct ctdb_control_gratious_arp, iface)) {
+ DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_gratious_arp structure. Got %u require %u bytes\n",
+ (unsigned)indata.dsize,
+ (unsigned)offsetof(struct ctdb_control_gratious_arp, iface)));
+ return -1;
+ }
+ if (indata.dsize !=
+ ( offsetof(struct ctdb_control_gratious_arp, iface)
+ + gratious_arp->len ) ){
+
+ DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
+ "but should be %u bytes\n",
+ (unsigned)indata.dsize,
+ (unsigned)(offsetof(struct ctdb_control_gratious_arp, iface)+gratious_arp->len)));
+ return -1;
+ }
+
+
+ arp = talloc(ctdb, struct control_gratious_arp);
+ CTDB_NO_MEMORY(ctdb, arp);
+
+ arp->ctdb = ctdb;
+ arp->addr = gratious_arp->addr;
+ arp->iface = talloc_strdup(arp, gratious_arp->iface);
+ CTDB_NO_MEMORY(ctdb, arp->iface);
+ arp->count = 0;
+
+ event_add_timed(arp->ctdb->ev, arp,
+ timeval_zero(), send_gratious_arp, arp);
+
+ return 0;
+}
+
+int32_t ctdb_control_add_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
+{
+ struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
+ int ret;
+
+ /* verify the size of indata */
+ if (indata.dsize < offsetof(struct ctdb_control_ip_iface, iface)) {
+ DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_ip_iface structure\n"));
+ return -1;
+ }
+ if (indata.dsize !=
+ ( offsetof(struct ctdb_control_ip_iface, iface)
+ + pub->len ) ){
+
+ DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
+ "but should be %u bytes\n",
+ (unsigned)indata.dsize,
+ (unsigned)(offsetof(struct ctdb_control_ip_iface, iface)+pub->len)));
+ return -1;
+ }
+
+ ret = ctdb_add_public_address(ctdb, &pub->addr, pub->mask, &pub->iface[0]);
+
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to add public address\n"));
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ called when releaseip event finishes for del_public_address
+ */
+static void delete_ip_callback(struct ctdb_context *ctdb, int status,
+ void *private_data)
+{
+ talloc_free(private_data);
+}
+
+int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA indata)
+{
+ struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
+ struct ctdb_vnn *vnn;
+ int ret;
+
+ /* verify the size of indata */
+ if (indata.dsize < offsetof(struct ctdb_control_ip_iface, iface)) {
+ DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_control_ip_iface structure\n"));
+ return -1;
+ }
+ if (indata.dsize !=
+ ( offsetof(struct ctdb_control_ip_iface, iface)
+ + pub->len ) ){
+
+ DEBUG(DEBUG_ERR,(__location__ " Wrong size of indata. Was %u bytes "
+ "but should be %u bytes\n",
+ (unsigned)indata.dsize,
+ (unsigned)(offsetof(struct ctdb_control_ip_iface, iface)+pub->len)));
+ return -1;
+ }
+
+ /* walk over all public addresses until we find a match */
+ for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
+ if (ctdb_same_ip(&vnn->public_address, &pub->addr)) {
+ TALLOC_CTX *mem_ctx = talloc_new(ctdb);
+
+ DLIST_REMOVE(ctdb->vnn, vnn);
+
+ ret = ctdb_event_script_callback(ctdb,
+ mem_ctx, delete_ip_callback, mem_ctx,
+ false,
+ CTDB_EVENT_RELEASE_IP,
+ "%s %s %u",
+ vnn->iface,
+ talloc_strdup(mem_ctx, ctdb_addr_to_str(&vnn->public_address)),
+ vnn->public_netmask_bits);
+ talloc_free(vnn);
+ if (ret != 0) {
+ return -1;
+ }
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+/* This function is called from the recovery daemon to verify that a remote
+ node has the expected ip allocation.
+ This is verified against ctdb->ip_tree
+*/
+int verify_remote_ip_allocation(struct ctdb_context *ctdb, struct ctdb_all_public_ips *ips)
+{
+ struct ctdb_public_ip_list *tmp_ip;
+ int i;
+
+ if (ctdb->ip_tree == NULL) {
+ /* dont know the expected allocation yet, assume remote node
+ is correct. */
+ return 0;
+ }
+
+ if (ips == NULL) {
+ return 0;
+ }
+
+ for (i=0; i<ips->num; i++) {
+ tmp_ip = trbt_lookuparray32(ctdb->ip_tree, IP_KEYLEN, ip_key(&ips->ips[i].addr));
+ if (tmp_ip == NULL) {
+ DEBUG(DEBUG_ERR,(__location__ " Could not find host for address %s, reassign ips\n", ctdb_addr_to_str(&ips->ips[i].addr)));
+ return -1;
+ }
+
+ if (tmp_ip->pnn == -1 || ips->ips[i].pnn == -1) {
+ continue;
+ }
+
+ if (tmp_ip->pnn != ips->ips[i].pnn) {
+ DEBUG(DEBUG_ERR,("Inconsistent ip allocation. Trigger reallocation. Thinks %s is held by node %u while it is held by node %u\n", ctdb_addr_to_str(&ips->ips[i].addr), ips->ips[i].pnn, tmp_ip->pnn));
+ return -1;
+ }
+ }
+
+ return 0;
+}
git.samba.org / metze / ctdb / wip.git / blobdiff