{
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;
*/
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)));
}
}
}
}
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",
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);
}
}
{
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->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;
TDB_DATA *outdata)
{
int i, num, len;
- struct ctdb_control_get_ifaces *ifaces;
+ struct ctdb_iface_list_old *ifaces;
struct ctdb_interface *cur;
/* count how many public ip structures we have */
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;
struct ctdb_req_control_old *c,
TDB_DATA indata)
{
- struct ctdb_control_iface_info *info;
+ 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 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;
}
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;
}
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;