enum ctdb_runstate runstate;
};
-struct ctdb_iface {
- struct ctdb_iface *prev, *next;
+struct ctdb_interface {
+ struct ctdb_interface *prev, *next;
const char *name;
bool link_up;
uint32_t references;
static int ctdb_add_local_iface(struct ctdb_context *ctdb, const char *iface)
{
- struct ctdb_iface *i;
+ struct ctdb_interface *i;
- /* Verify that we dont have an entry for this ip yet */
+ /* Verify that we don't have an entry for this ip yet */
for (i=ctdb->ifaces;i;i=i->next) {
if (strcmp(i->name, iface) == 0) {
return 0;
}
/* create a new structure for this interface */
- i = talloc_zero(ctdb, struct ctdb_iface);
+ i = talloc_zero(ctdb, struct ctdb_interface);
CTDB_NO_MEMORY_FATAL(ctdb, i);
i->name = talloc_strdup(i, iface);
CTDB_NO_MEMORY(ctdb, i->name);
static void ctdb_remove_orphaned_ifaces(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- struct ctdb_iface *i, *next;
+ struct ctdb_interface *i, *next;
/* For each interface, check if there's an IP using it. */
for (i = ctdb->ifaces; i != NULL; i = next) {
}
-static struct ctdb_iface *ctdb_find_iface(struct ctdb_context *ctdb,
- const char *iface)
+static struct ctdb_interface *ctdb_find_iface(struct ctdb_context *ctdb,
+ const char *iface)
{
- struct ctdb_iface *i;
+ struct ctdb_interface *i;
for (i=ctdb->ifaces;i;i=i->next) {
if (strcmp(i->name, iface) == 0) {
return NULL;
}
-static struct ctdb_iface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
- struct ctdb_vnn *vnn)
+static struct ctdb_interface *ctdb_vnn_best_iface(struct ctdb_context *ctdb,
+ struct ctdb_vnn *vnn)
{
int i;
- struct ctdb_iface *cur = NULL;
- struct ctdb_iface *best = NULL;
+ struct ctdb_interface *cur = NULL;
+ struct ctdb_interface *best = NULL;
for (i=0; vnn->ifaces[i]; i++) {
static int32_t ctdb_vnn_assign_iface(struct ctdb_context *ctdb,
struct ctdb_vnn *vnn)
{
- struct ctdb_iface *best = NULL;
+ struct ctdb_interface *best = NULL;
if (vnn->iface) {
DEBUG(DEBUG_INFO, (__location__ " public address '%s' "
}
for (i=0; vnn->ifaces[i]; i++) {
- struct ctdb_iface *cur;
+ struct ctdb_interface *cur;
cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
if (cur == NULL) {
*/
struct ctdb_tcp_list {
struct ctdb_tcp_list *prev, *next;
- struct ctdb_tcp_connection connection;
+ struct ctdb_connection connection;
};
/*
tcparray = arp->tcparray;
if (tcparray) {
for (i=0;i<tcparray->num;i++) {
- struct ctdb_tcp_connection *tcon;
+ struct ctdb_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)));
+ (unsigned)ntohs(tcon->dst.ip.sin_port),
+ ctdb_addr_to_str(&tcon->src),
+ (unsigned)ntohs(tcon->src.ip.sin_port)));
ret = ctdb_sys_send_tcp(
- &tcon->src_addr,
- &tcon->dst_addr,
+ &tcon->src,
+ &tcon->dst,
0, 0, 0);
if (ret != 0) {
DEBUG(DEBUG_CRIT,(__location__ " Failed to send tcp tickle ack for %s\n",
- ctdb_addr_to_str(&tcon->src_addr)));
+ ctdb_addr_to_str(&tcon->src)));
}
}
}
}
struct takeover_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
ctdb_sock_addr *addr;
struct ctdb_vnn *vnn;
};
struct ctdb_do_takeip_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
struct ctdb_vnn *vnn;
};
take over an ip address
*/
static int32_t ctdb_do_takeip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
struct ctdb_vnn *vnn)
{
int ret;
}
struct ctdb_do_updateip_state {
- struct ctdb_req_control *c;
- struct ctdb_iface *old;
+ struct ctdb_req_control_old *c;
+ struct ctdb_interface *old;
struct ctdb_vnn *vnn;
};
update (move) an ip address
*/
static int32_t ctdb_do_updateip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
struct ctdb_vnn *vnn)
{
int ret;
struct ctdb_do_updateip_state *state;
- struct ctdb_iface *old = vnn->iface;
+ struct ctdb_interface *old = vnn->iface;
const char *new_name;
if (vnn->update_in_flight) {
take over an ip address
*/
int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
bool *async_reply)
{
bool have_ip = false;
bool do_updateip = false;
bool do_takeip = false;
- struct ctdb_iface *best_iface = NULL;
+ struct ctdb_interface *best_iface = NULL;
if (pip->pnn != ctdb->pnn) {
DEBUG(DEBUG_ERR,(__location__" takeoverip called for an ip '%s' "
release an ip address
*/
int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
bool *async_reply)
{
}
free(tmp);
- /* Verify that we dont have an entry for this ip yet */
+ /* Verify that we don't have an entry for this ip yet */
for (vnn=ctdb->vnn;vnn;vnn=vnn->next) {
if (ctdb_same_sockaddr(addr, &vnn->public_address)) {
DEBUG(DEBUG_CRIT,("Same ip '%s' specified multiple times in the public address list \n",
const char *ip)
{
struct ctdb_vnn *svnn;
- struct ctdb_iface *cur = NULL;
+ struct ctdb_interface *cur = NULL;
bool ok;
int ret;
return 0;
}
-struct ctdb_public_ip_list {
- struct ctdb_public_ip_list *next;
+struct public_ip_list {
+ struct public_ip_list *next;
uint32_t pnn;
ctdb_sock_addr addr;
};
/* Given a physical node, return the number of
public addresses that is currently assigned to this node.
*/
-static int node_ip_coverage(struct ctdb_context *ctdb,
- int32_t pnn,
- struct ctdb_public_ip_list *ips)
+static int node_ip_coverage(struct ctdb_context *ctdb, int32_t pnn,
+ struct public_ip_list *ips)
{
int num=0;
/* Can the given node host the given IP: is the public IP known to the
* node and is NOIPHOST unset?
*/
-static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
+static bool can_node_host_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags,
- struct ctdb_public_ip_list *ip)
+ struct public_ip_list *ip)
{
- struct ctdb_all_public_ips *public_ips;
+ struct ctdb_public_ip_list_old *public_ips;
int i;
if (ipflags.noiphost) {
return false;
}
-static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
+static bool can_node_takeover_ip(struct ctdb_context *ctdb, int32_t pnn,
struct ctdb_ipflags ipflags,
- struct ctdb_public_ip_list *ip)
+ struct public_ip_list *ip)
{
if (ipflags.noiptakeover) {
return false;
pick the node that currently are serving the least number of ips
so that the ips get spread out evenly.
*/
-static int find_takeover_node(struct ctdb_context *ctdb,
- struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *ip,
- struct ctdb_public_ip_list *all_ips)
+static int find_takeover_node(struct ctdb_context *ctdb,
+ struct ctdb_ipflags *ipflags,
+ struct public_ip_list *ip,
+ struct public_ip_list *all_ips)
{
int pnn, min=0, num;
int i, numnodes;
static void *add_ip_callback(void *parm, void *data)
{
- struct ctdb_public_ip_list *this_ip = parm;
- struct ctdb_public_ip_list *prev_ip = data;
+ struct public_ip_list *this_ip = parm;
+ struct public_ip_list *prev_ip = data;
if (prev_ip == NULL) {
return parm;
static int 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;
+ struct public_ip_list **ip_list = (struct public_ip_list **)param;
+ struct public_ip_list *new_ip = (struct public_ip_list *)data;
new_ip->next = *ip_list;
*ip_list = new_ip;
return 0;
}
-static struct ctdb_public_ip_list *
+static struct public_ip_list *
create_merged_ip_list(struct ctdb_context *ctdb)
{
int i, j;
- struct ctdb_public_ip_list *ip_list;
- struct ctdb_all_public_ips *public_ips;
+ struct public_ip_list *ip_list;
+ struct ctdb_public_ip_list_old *public_ips;
if (ctdb->ip_tree != NULL) {
talloc_free(ctdb->ip_tree);
}
for (j=0;j<public_ips->num;j++) {
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
- tmp_ip = talloc_zero(ctdb->ip_tree, struct ctdb_public_ip_list);
+ tmp_ip = talloc_zero(ctdb->ip_tree, struct public_ip_list);
CTDB_NO_MEMORY_NULL(ctdb, tmp_ip);
/* Do not use information about IP addresses hosted
* on other nodes, it may not be accurate */
used in the main part of the algorithm.
*/
static uint32_t ip_distance_2_sum(ctdb_sock_addr *ip,
- struct ctdb_public_ip_list *ips,
+ struct public_ip_list *ips,
int pnn)
{
- struct ctdb_public_ip_list *t;
+ struct public_ip_list *t;
uint32_t d;
uint32_t sum = 0;
/* Return the LCP2 imbalance metric for addresses currently assigned
to the given node.
*/
-static uint32_t lcp2_imbalance(struct ctdb_public_ip_list * all_ips, int pnn)
+static uint32_t lcp2_imbalance(struct public_ip_list * all_ips, int pnn)
{
- struct ctdb_public_ip_list *t;
+ struct public_ip_list *t;
uint32_t imbalance = 0;
*/
static void basic_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
/* loop over all ip's and find a physical node to cover for
each unassigned ip.
*/
static void basic_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
int num_ips)
{
int i, numnodes;
int maxnode, maxnum, minnode, minnum, num, retries;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags);
retries = 0;
*/
if ( (maxnum > minnum+1)
&& (retries < (num_ips + 5)) ){
- struct ctdb_public_ip_list *tmp;
+ struct public_ip_list *tmp;
/* Reassign one of maxnode's VNNs */
for (tmp=all_ips;tmp;tmp=tmp->next) {
static void lcp2_init(struct ctdb_context *tmp_ctx,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes,
uint32_t **lcp2_imbalances,
bool **rebalance_candidates)
{
int i, numnodes;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
numnodes = talloc_array_length(ipflags);
*/
static void lcp2_allocate_unassigned(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int dstnode, numnodes;
int minnode;
uint32_t mindsum, dstdsum, dstimbl, minimbl;
- struct ctdb_public_ip_list *minip;
+ struct public_ip_list *minip;
bool should_loop = true;
bool have_unassigned = true;
*/
static bool lcp2_failback_candidate(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
int srcnode,
uint32_t *lcp2_imbalances,
bool *rebalance_candidates)
int dstnode, mindstnode, numnodes;
uint32_t srcimbl, srcdsum, dstimbl, dstdsum;
uint32_t minsrcimbl, mindstimbl;
- struct ctdb_public_ip_list *minip;
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *minip;
+ struct public_ip_list *tmp_ip;
/* Find an IP and destination node that best reduces imbalance. */
srcimbl = 0;
*/
static void lcp2_failback(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *lcp2_imbalances,
bool *rebalance_candidates)
{
static void unassign_unsuitable_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
/* verify that the assigned nodes can serve that public ip
and set it to -1 if not
static void ip_alloc_deterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int i, numnodes;
numnodes = talloc_array_length(ipflags);
static void ip_alloc_nondeterministic_ips(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips)
+ struct public_ip_list *all_ips)
{
/* This should be pushed down into basic_failback. */
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int num_ips = 0;
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
num_ips++;
static void ip_alloc_lcp2(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list *all_ips,
+ struct public_ip_list *all_ips,
uint32_t *force_rebalance_nodes)
{
uint32_t *lcp2_imbalances;
talloc_free(tmp_ctx);
}
-static bool all_nodes_are_disabled(struct ctdb_node_map *nodemap)
+static bool all_nodes_are_disabled(struct ctdb_node_map_old *nodemap)
{
int i;
/* The calculation part of the IP allocation algorithm. */
static void ctdb_takeover_run_core(struct ctdb_context *ctdb,
struct ctdb_ipflags *ipflags,
- struct ctdb_public_ip_list **all_ips_p,
+ struct public_ip_list **all_ips_p,
uint32_t *force_rebalance_nodes)
{
/* since nodes only know about those public addresses that
static uint32_t *get_tunable_from_nodes(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
const char *tunable,
uint32_t default_value)
{
static enum ctdb_runstate * get_runstate_from_nodes(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
enum ctdb_runstate default_value)
{
uint32_t *nodes;
static struct ctdb_ipflags *
set_ipflags_internal(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap,
+ struct ctdb_node_map_old *nodemap,
uint32_t *tval_noiptakeover,
uint32_t *tval_noiphostonalldisabled,
enum ctdb_runstate *runstate)
static struct ctdb_ipflags *set_ipflags(struct ctdb_context *ctdb,
TALLOC_CTX *tmp_ctx,
- struct ctdb_node_map *nodemap)
+ struct ctdb_node_map_old *nodemap)
{
uint32_t *tval_noiptakeover;
uint32_t *tval_noiphostonalldisabled;
int retry_count;
client_async_callback fail_callback;
void *fail_callback_data;
- struct ctdb_node_map *nodemap;
+ struct ctdb_node_map_old *nodemap;
};
static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
bool *node_failed;
client_async_callback fail_callback;
void *fail_callback_data;
- struct ctdb_node_map *nodemap;
+ struct ctdb_node_map_old *nodemap;
};
static void takeover_run_fail_callback(struct ctdb_context *ctdb,
/*
make any IP alias changes for public addresses that are necessary
*/
-int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map *nodemap,
+int ctdb_takeover_run(struct ctdb_context *ctdb, struct ctdb_node_map_old *nodemap,
uint32_t *force_rebalance_nodes,
client_async_callback fail_callback, void *callback_data)
{
int i, j, ret;
struct ctdb_public_ip ip;
uint32_t *nodes;
- struct ctdb_public_ip_list *all_ips, *tmp_ip;
+ struct public_ip_list *all_ips, *tmp_ip;
TDB_DATA data;
struct timeval timeout;
struct client_async_data *async_data;
for (tmp_ip=all_ips;tmp_ip;tmp_ip=tmp_ip->next) {
if (tmp_ip->pnn == nodemap->nodes[i].pnn) {
/* This node should be serving this
- vnn so dont tell it to release the ip
+ vnn so don't tell it to release the ip
*/
continue;
}
TDB_DATA indata)
{
struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
- struct ctdb_control_tcp_addr *tcp_sock = NULL;
+ struct ctdb_connection *tcp_sock = NULL;
struct ctdb_tcp_list *tcp;
- struct ctdb_tcp_connection t;
+ struct ctdb_connection t;
int ret;
TDB_DATA data;
struct ctdb_client_ip *ip;
return 0;
}
- tcp_sock = (struct ctdb_control_tcp_addr *)indata.dptr;
+ tcp_sock = (struct ctdb_connection *)indata.dptr;
addr = tcp_sock->src;
ctdb_canonicalize_ip(&addr, &tcp_sock->src);
- addr = tcp_sock->dest;
- ctdb_canonicalize_ip(&addr, &tcp_sock->dest);
+ addr = tcp_sock->dst;
+ ctdb_canonicalize_ip(&addr, &tcp_sock->dst);
ZERO_STRUCT(addr);
- memcpy(&addr, &tcp_sock->dest, sizeof(addr));
+ memcpy(&addr, &tcp_sock->dst, sizeof(addr));
vnn = find_public_ip_vnn(ctdb, &addr);
if (vnn == NULL) {
switch (addr.sa.sa_family) {
tcp = talloc(client, struct ctdb_tcp_list);
CTDB_NO_MEMORY(ctdb, tcp);
- tcp->connection.src_addr = tcp_sock->src;
- tcp->connection.dst_addr = tcp_sock->dest;
+ tcp->connection.src = tcp_sock->src;
+ tcp->connection.dst = tcp_sock->dst;
DLIST_ADD(client->tcp_list, tcp);
- t.src_addr = tcp_sock->src;
- t.dst_addr = tcp_sock->dest;
+ t.src = tcp_sock->src;
+ t.dst = tcp_sock->dst;
data.dptr = (uint8_t *)&t;
data.dsize = sizeof(t);
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),
+ (unsigned)ntohs(tcp_sock->dst.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),
+ (unsigned)ntohs(tcp_sock->dst.ip6.sin6_port),
ctdb_addr_to_str(&tcp_sock->src),
(unsigned)ntohs(tcp_sock->src.ip6.sin6_port), client_id, client->pid));
break;
/*
find a tcp address on a list
*/
-static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
- struct ctdb_tcp_connection *tcp)
+static struct ctdb_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
+ struct ctdb_connection *tcp)
{
int i;
}
for (i=0;i<array->num;i++) {
- if (ctdb_same_sockaddr(&array->connections[i].src_addr, &tcp->src_addr) &&
- ctdb_same_sockaddr(&array->connections[i].dst_addr, &tcp->dst_addr)) {
+ if (ctdb_same_sockaddr(&array->connections[i].src, &tcp->src) &&
+ ctdb_same_sockaddr(&array->connections[i].dst, &tcp->dst)) {
return &array->connections[i];
}
}
*/
int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tcp_update_needed)
{
- struct ctdb_tcp_connection *p = (struct ctdb_tcp_connection *)indata.dptr;
+ struct ctdb_connection *p = (struct ctdb_connection *)indata.dptr;
struct ctdb_tcp_array *tcparray;
- struct ctdb_tcp_connection tcp;
+ struct ctdb_connection tcp;
struct ctdb_vnn *vnn;
/* If we don't have public IPs, tickles are useless */
return 0;
}
- vnn = find_public_ip_vnn(ctdb, &p->dst_addr);
+ vnn = find_public_ip_vnn(ctdb, &p->dst);
if (vnn == NULL) {
DEBUG(DEBUG_INFO,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n",
- ctdb_addr_to_str(&p->dst_addr)));
+ ctdb_addr_to_str(&p->dst)));
return -1;
}
vnn->tcp_array = tcparray;
tcparray->num = 0;
- tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_tcp_connection));
+ tcparray->connections = talloc_size(tcparray, sizeof(struct ctdb_connection));
CTDB_NO_MEMORY(ctdb, tcparray->connections);
- tcparray->connections[tcparray->num].src_addr = p->src_addr;
- tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
+ tcparray->connections[tcparray->num].src = p->src;
+ tcparray->connections[tcparray->num].dst = p->dst;
tcparray->num++;
if (tcp_update_needed) {
/* Do we already have this tickle ?*/
- tcp.src_addr = p->src_addr;
- tcp.dst_addr = p->dst_addr;
+ tcp.src = p->src;
+ tcp.dst = p->dst;
if (ctdb_tcp_find(tcparray, &tcp) != NULL) {
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),
+ ctdb_addr_to_str(&tcp.dst),
+ ntohs(tcp.dst.ip.sin_port),
vnn->pnn));
return 0;
}
/* A new tickle, we must add it to the array */
tcparray->connections = talloc_realloc(tcparray, tcparray->connections,
- struct ctdb_tcp_connection,
+ struct ctdb_connection,
tcparray->num+1);
CTDB_NO_MEMORY(ctdb, tcparray->connections);
- tcparray->connections[tcparray->num].src_addr = p->src_addr;
- tcparray->connections[tcparray->num].dst_addr = p->dst_addr;
+ tcparray->connections[tcparray->num].src = p->src;
+ tcparray->connections[tcparray->num].dst = p->dst;
tcparray->num++;
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),
+ ctdb_addr_to_str(&tcp.dst),
+ ntohs(tcp.dst.ip.sin_port),
vnn->pnn));
if (tcp_update_needed) {
clients managing that should tickled with an ACK when IP takeover is
done
*/
-static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tcp_connection *conn)
+static void ctdb_remove_connection(struct ctdb_context *ctdb, struct ctdb_connection *conn)
{
- struct ctdb_tcp_connection *tcpp;
- struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst_addr);
+ struct ctdb_connection *tcpp;
+ struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst);
if (vnn == NULL) {
DEBUG(DEBUG_ERR,(__location__ " unable to find public address %s\n",
- ctdb_addr_to_str(&conn->dst_addr)));
+ ctdb_addr_to_str(&conn->dst)));
return;
}
/* if the array is empty we cant remove it
- and we dont need to do anything
+ and we don't need to do anything
*/
if (vnn->tcp_array == NULL) {
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)));
+ ctdb_addr_to_str(&conn->dst),
+ ntohs(conn->dst.ip.sin_port)));
return;
}
/* See if we know this connection
- if we dont know this connection then we dont need to do anything
+ if we don't know this connection then we dont need to do anything
*/
tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
if (tcpp == NULL) {
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)));
+ ctdb_addr_to_str(&conn->dst),
+ ntohs(conn->dst.ip.sin_port)));
return;
}
vnn->tcp_update_needed = true;
DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n",
- ctdb_addr_to_str(&conn->src_addr),
- ntohs(conn->src_addr.ip.sin_port)));
+ ctdb_addr_to_str(&conn->src),
+ ntohs(conn->src.ip.sin_port)));
}
*/
int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata)
{
- struct ctdb_tcp_connection *conn = (struct ctdb_tcp_connection *)indata.dptr;
+ struct ctdb_connection *conn = (struct ctdb_connection *)indata.dptr;
/* If we don't have public IPs, tickles are useless */
if (ctdb->vnn == NULL) {
return 0;
}
- ctdb_remove_tcp_connection(ctdb, conn);
+ ctdb_remove_connection(ctdb, conn);
return 0;
}
while (client->tcp_list) {
struct ctdb_tcp_list *tcp = client->tcp_list;
DLIST_REMOVE(client->tcp_list, tcp);
- ctdb_remove_tcp_connection(client->ctdb, &tcp->connection);
+ ctdb_remove_connection(client->ctdb, &tcp->connection);
}
}
get list of public IPs
*/
int32_t ctdb_control_get_public_ips(struct ctdb_context *ctdb,
- struct ctdb_req_control *c, TDB_DATA *outdata)
+ struct ctdb_req_control_old *c, TDB_DATA *outdata)
{
int i, num, len;
- struct ctdb_all_public_ips *ips;
+ struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
bool only_available = false;
num++;
}
- len = offsetof(struct ctdb_all_public_ips, ips) +
+ len = offsetof(struct ctdb_public_ip_list_old, ips) +
num*sizeof(struct ctdb_public_ip);
ips = talloc_zero_size(outdata, len);
CTDB_NO_MEMORY(ctdb, ips);
i++;
}
ips->num = i;
- len = offsetof(struct ctdb_all_public_ips, ips) +
+ len = offsetof(struct ctdb_public_ip_list_old, ips) +
i*sizeof(struct ctdb_public_ip);
outdata->dsize = len;
int32_t ctdb_control_get_public_ip_info(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata,
TDB_DATA *outdata)
{
int i, num, len;
ctdb_sock_addr *addr;
- struct ctdb_control_public_ip_info *info;
+ struct ctdb_public_ip_info_old *info;
struct ctdb_vnn *vnn;
addr = (ctdb_sock_addr *)indata.dptr;
num++;
}
- len = offsetof(struct ctdb_control_public_ip_info, ifaces) +
- num*sizeof(struct ctdb_control_iface_info);
+ len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
+ num*sizeof(struct ctdb_iface);
info = talloc_zero_size(outdata, len);
CTDB_NO_MEMORY(ctdb, info);
info->active_idx = 0xFFFFFFFF;
for (i=0; vnn->ifaces[i]; i++) {
- struct ctdb_iface *cur;
+ struct ctdb_interface *cur;
cur = ctdb_find_iface(ctdb, vnn->ifaces[i]);
if (cur == NULL) {
info->ifaces[i].references = cur->references;
}
info->num = i;
- len = offsetof(struct ctdb_control_public_ip_info, ifaces) +
- i*sizeof(struct ctdb_control_iface_info);
+ len = offsetof(struct ctdb_public_ip_info_old, ifaces) +
+ i*sizeof(struct ctdb_iface);
outdata->dsize = len;
outdata->dptr = (uint8_t *)info;
}
int32_t ctdb_control_get_ifaces(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA *outdata)
{
int i, num, len;
- struct ctdb_control_get_ifaces *ifaces;
- struct ctdb_iface *cur;
+ struct ctdb_iface_list_old *ifaces;
+ struct ctdb_interface *cur;
/* count how many public ip structures we have */
num = 0;
num++;
}
- len = offsetof(struct ctdb_control_get_ifaces, ifaces) +
- num*sizeof(struct ctdb_control_iface_info);
+ len = offsetof(struct ctdb_iface_list_old, ifaces) +
+ num*sizeof(struct ctdb_iface);
ifaces = talloc_zero_size(outdata, len);
CTDB_NO_MEMORY(ctdb, ifaces);
i++;
}
ifaces->num = i;
- len = offsetof(struct ctdb_control_get_ifaces, ifaces) +
- i*sizeof(struct ctdb_control_iface_info);
+ len = offsetof(struct ctdb_iface_list_old, ifaces) +
+ i*sizeof(struct ctdb_iface);
outdata->dsize = len;
outdata->dptr = (uint8_t *)ifaces;
}
int32_t ctdb_control_set_iface_link(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata)
{
- struct ctdb_control_iface_info *info;
- struct ctdb_iface *iface;
+ struct ctdb_iface *info;
+ struct ctdb_interface *iface;
bool link_up = false;
- info = (struct ctdb_control_iface_info *)indata.dptr;
+ info = (struct ctdb_iface *)indata.dptr;
if (info->name[CTDB_IFACE_SIZE] != '\0') {
int len = strnlen(info->name, CTDB_IFACE_SIZE);
/* nothing fancy here, just unconditionally replace any existing
connection structure with the new one.
- dont even free the old one if it did exist, that one is talloc_stolen
+ don't even free the old one if it did exist, that one is talloc_stolen
by the same node in the tree anyway and will be deleted when the new data
is deleted
*/
add_killtcp_callback, con);
/*
- If we dont have a socket to listen on yet we must create it
+ If we don't have a socket to listen on yet we must create it
*/
if (killtcp->capture_fd == -1) {
const char *iface = ctdb_vnn_iface_string(vnn);
*/
int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata)
{
- struct ctdb_tcp_connection *killtcp = (struct ctdb_tcp_connection *)indata.dptr;
+ struct ctdb_connection *killtcp = (struct ctdb_connection *)indata.dptr;
- return ctdb_killtcp_add_connection(ctdb, &killtcp->src_addr, &killtcp->dst_addr);
+ return ctdb_killtcp_add_connection(ctdb, &killtcp->src, &killtcp->dst);
}
/*
*/
int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata)
{
- struct ctdb_control_tcp_tickle_list *list = (struct ctdb_control_tcp_tickle_list *)indata.dptr;
+ struct ctdb_tickle_list_old *list = (struct ctdb_tickle_list_old *)indata.dptr;
struct ctdb_tcp_array *tcparray;
struct ctdb_vnn *vnn;
/* We must at least have tickles.num or else we cant verify the size
of the received data blob
*/
- if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
- tickles.connections)) {
- DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list. Not enough data for the tickle.num field\n"));
+ if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)) {
+ DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list. Not enough data for the tickle.num field\n"));
return -1;
}
/* verify that the size of data matches what we expect */
- if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
- tickles.connections)
- + sizeof(struct ctdb_tcp_connection)
- * list->tickles.num) {
- DEBUG(DEBUG_ERR,("Bad indata in ctdb_control_set_tcp_tickle_list\n"));
+ if (indata.dsize < offsetof(struct ctdb_tickle_list_old, connections)
+ + sizeof(struct ctdb_connection) * list->num) {
+ DEBUG(DEBUG_ERR,("Bad indata in ctdb_tickle_list\n"));
return -1;
}
tcparray = talloc(vnn, struct ctdb_tcp_array);
CTDB_NO_MEMORY(ctdb, tcparray);
- tcparray->num = list->tickles.num;
+ tcparray->num = list->num;
- tcparray->connections = talloc_array(tcparray, struct ctdb_tcp_connection, tcparray->num);
+ tcparray->connections = talloc_array(tcparray, struct ctdb_connection, tcparray->num);
CTDB_NO_MEMORY(ctdb, tcparray->connections);
- memcpy(tcparray->connections, &list->tickles.connections[0],
- sizeof(struct ctdb_tcp_connection)*tcparray->num);
+ memcpy(tcparray->connections, &list->connections[0],
+ sizeof(struct ctdb_connection)*tcparray->num);
/* We now have a new fresh tickle list array for this vnn */
vnn->tcp_array = tcparray;
int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA indata, TDB_DATA *outdata)
{
ctdb_sock_addr *addr = (ctdb_sock_addr *)indata.dptr;
- struct ctdb_control_tcp_tickle_list *list;
+ struct ctdb_tickle_list_old *list;
struct ctdb_tcp_array *tcparray;
int num;
struct ctdb_vnn *vnn;
num = 0;
}
- outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list,
- tickles.connections)
- + sizeof(struct ctdb_tcp_connection) * num;
+ outdata->dsize = offsetof(struct ctdb_tickle_list_old, connections)
+ + sizeof(struct ctdb_connection) * num;
outdata->dptr = talloc_size(outdata, outdata->dsize);
CTDB_NO_MEMORY(ctdb, outdata->dptr);
- list = (struct ctdb_control_tcp_tickle_list *)outdata->dptr;
+ list = (struct ctdb_tickle_list_old *)outdata->dptr;
list->addr = *addr;
- list->tickles.num = num;
+ list->num = num;
if (num) {
- memcpy(&list->tickles.connections[0], tcparray->connections,
- sizeof(struct ctdb_tcp_connection) * num);
+ memcpy(&list->connections[0], tcparray->connections,
+ sizeof(struct ctdb_connection) * num);
}
return 0;
{
int ret, num;
TDB_DATA data;
- struct ctdb_control_tcp_tickle_list *list;
+ struct ctdb_tickle_list_old *list;
if (tcparray) {
num = tcparray->num;
num = 0;
}
- data.dsize = offsetof(struct ctdb_control_tcp_tickle_list,
- tickles.connections) +
- sizeof(struct ctdb_tcp_connection) * num;
+ data.dsize = offsetof(struct ctdb_tickle_list_old, connections) +
+ sizeof(struct ctdb_connection) * num;
data.dptr = talloc_size(ctdb, data.dsize);
CTDB_NO_MEMORY(ctdb, data.dptr);
- list = (struct ctdb_control_tcp_tickle_list *)data.dptr;
+ list = (struct ctdb_tickle_list_old *)data.dptr;
list->addr = *addr;
- list->tickles.num = num;
+ list->num = num;
if (tcparray) {
- memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num);
+ memcpy(&list->connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
}
ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,
*/
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 ctdb_addr_info_old *gratious_arp = (struct ctdb_addr_info_old *)indata.dptr;
struct control_gratious_arp *arp;
/* verify the size of indata */
- if (indata.dsize < offsetof(struct ctdb_control_gratious_arp, iface)) {
+ if (indata.dsize < offsetof(struct ctdb_addr_info_old, 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)));
+ (unsigned)offsetof(struct ctdb_addr_info_old, iface)));
return -1;
}
if (indata.dsize !=
- ( offsetof(struct ctdb_control_gratious_arp, iface)
+ ( offsetof(struct ctdb_addr_info_old, 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)));
+ (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+gratious_arp->len)));
return -1;
}
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;
+ struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)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"));
+ if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
+ DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
return -1;
}
if (indata.dsize !=
- ( offsetof(struct ctdb_control_ip_iface, iface)
+ ( offsetof(struct ctdb_addr_info_old, 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)));
+ (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
return -1;
}
}
struct delete_ip_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
};
/*
}
int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
TDB_DATA indata, bool *async_reply)
{
- struct ctdb_control_ip_iface *pub = (struct ctdb_control_ip_iface *)indata.dptr;
+ struct ctdb_addr_info_old *pub = (struct ctdb_addr_info_old *)indata.dptr;
struct ctdb_vnn *vnn;
/* 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"));
+ if (indata.dsize < offsetof(struct ctdb_addr_info_old, iface)) {
+ DEBUG(DEBUG_ERR,(__location__ " Too small indata to hold a ctdb_addr_info structure\n"));
return -1;
}
if (indata.dsize !=
- ( offsetof(struct ctdb_control_ip_iface, iface)
+ ( offsetof(struct ctdb_addr_info_old, 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)));
+ (unsigned)(offsetof(struct ctdb_addr_info_old, iface)+pub->len)));
return -1;
}
struct ipreallocated_callback_state {
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
};
static void ctdb_ipreallocated_callback(struct ctdb_context *ctdb,
/* A control to run the ipreallocated event */
int32_t ctdb_control_ipreallocated(struct ctdb_context *ctdb,
- struct ctdb_req_control *c,
+ struct ctdb_req_control_old *c,
bool *async_reply)
{
int ret;
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_old *ips,
uint32_t pnn)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
int i;
if (ctdb->ip_tree == NULL) {
- /* dont know the expected allocation yet, assume remote node
+ /* don't know the expected allocation yet, assume remote node
is correct. */
return 0;
}
int update_ip_assignment_tree(struct ctdb_context *ctdb, struct ctdb_public_ip *ip)
{
- struct ctdb_public_ip_list *tmp_ip;
+ struct public_ip_list *tmp_ip;
/* IP tree is never built if DisableIPFailover is set */
if (ctdb->tunable.disable_ip_failover != 0) {
struct ctdb_reloadips_handle {
struct ctdb_context *ctdb;
- struct ctdb_req_control *c;
+ struct ctdb_req_control_old *c;
int status;
int fd[2];
pid_t child;
static int ctdb_reloadips_child(struct ctdb_context *ctdb)
{
TALLOC_CTX *mem_ctx = talloc_new(NULL);
- struct ctdb_all_public_ips *ips;
+ struct ctdb_public_ip_list_old *ips;
struct ctdb_vnn *vnn;
struct client_async_data *async_data;
struct timeval timeout;
if (vnn == NULL) {
/* Delete IP ips->ips[i] */
- struct ctdb_control_ip_iface *pub;
+ struct ctdb_addr_info_old *pub;
DEBUG(DEBUG_NOTICE,
("IP %s no longer configured, deleting it\n",
ctdb_addr_to_str(&ips->ips[i].addr)));
- pub = talloc_zero(mem_ctx,
- struct ctdb_control_ip_iface);
+ pub = talloc_zero(mem_ctx, struct ctdb_addr_info_old);
CTDB_NO_MEMORY(ctdb, pub);
pub->addr = ips->ips[i].addr;
timeout = TAKEOVER_TIMEOUT();
- data.dsize = offsetof(struct ctdb_control_ip_iface,
+ data.dsize = offsetof(struct ctdb_addr_info_old,
iface) + pub->len;
data.dptr = (uint8_t *)pub;
}
if (i == ips->num) {
/* Add IP ips->ips[i] */
- struct ctdb_control_ip_iface *pub;
+ struct ctdb_addr_info_old *pub;
const char *ifaces = NULL;
uint32_t len;
int iface = 0;
len = strlen(ifaces) + 1;
pub = talloc_zero_size(mem_ctx,
- offsetof(struct ctdb_control_ip_iface, iface) + len);
+ offsetof(struct ctdb_addr_info_old, iface) + len);
CTDB_NO_MEMORY(ctdb, pub);
pub->addr = vnn->public_address;
timeout = TAKEOVER_TIMEOUT();
- data.dsize = offsetof(struct ctdb_control_ip_iface,
+ data.dsize = offsetof(struct ctdb_addr_info_old,
iface) + pub->len;
data.dptr = (uint8_t *)pub;
and drop any addresses we should nnot longer host, and add new addresses
that we are now able to host
*/
-int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control *c, bool *async_reply)
+int32_t ctdb_control_reload_public_ips(struct ctdb_context *ctdb, struct ctdb_req_control_old *c, bool *async_reply)
{
struct ctdb_reloadips_handle *h;
pid_t parent = getpid();
git.samba.org / metze / samba / wip.git / blobdiff