sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-28 01:58:17 +03:00
Code

ctdb-daemon: Rename struct ctdb_tcp_connection to ctdb_connection

Browse Source 
Signed-off-by: Amitay Isaacs <amitay@gmail.com>
Reviewed-by: Martin Schwenke <martin@meltin.net>
This commit is contained in:
Amitay Isaacs 2015-10-28 18:14:21 +11:00 committed by Martin Schwenke
parent a82ee238b5
commit 92a6ac18ae
7 changed files with 84 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ctdb/client/ctdb_client.c
View File

@ -3113,13 +3113,13 @@ int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb,
int ctdb_ctrl_killtcp(struct ctdb_context *ctdb, int ctdb_ctrl_killtcp(struct ctdb_context *ctdb,
struct timeval timeout, struct timeval timeout,
uint32_t destnode, uint32_t destnode,
struct ctdb_tcp_connection *killtcp) struct ctdb_connection *killtcp)
{ {
TDB_DATA data; TDB_DATA data;
int32_t res; int32_t res;
int ret; int ret;
data.dsize = sizeof(struct ctdb_tcp_connection); data.dsize = sizeof(struct ctdb_connection);
data.dptr = (unsigned char *)killtcp; data.dptr = (unsigned char *)killtcp;
ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_KILL_TCP, 0, data, NULL, ret = ctdb_control(ctdb, destnode, 0, CTDB_CONTROL_KILL_TCP, 0, data, NULL,

2
ctdb/include/ctdb_client.h
View File

@ -408,7 +408,7 @@ int ctdb_ctrl_del_public_ip(struct ctdb_context *ctdb,
int ctdb_ctrl_killtcp(struct ctdb_context *ctdb, int ctdb_ctrl_killtcp(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode, struct timeval timeout, uint32_t destnode,
struct ctdb_tcp_connection *killtcp); struct ctdb_connection *killtcp);
int ctdb_ctrl_gratious_arp(struct ctdb_context *ctdb, int ctdb_ctrl_gratious_arp(struct ctdb_context *ctdb,
struct timeval timeout, uint32_t destnode, struct timeval timeout, uint32_t destnode,

2
ctdb/include/ctdb_private.h
View File

@ -28,7 +28,7 @@
*/ */
struct ctdb_tcp_array { struct ctdb_tcp_array {
uint32_t num; uint32_t num;
struct ctdb_tcp_connection *connections; struct ctdb_connection *connections;
}; };
/* /*

11
ctdb/include/ctdb_protocol.h
View File

@ -837,19 +837,10 @@ struct srvid_request_data {
uint32_t data; uint32_t data;
}; };
/*
a tcp connection description
also used by tcp_add and tcp_remove controls
*/
struct ctdb_tcp_connection {
ctdb_sock_addr src_addr;
ctdb_sock_addr dst_addr;
};
/* the wire representation for a tcp tickle array */ /* the wire representation for a tcp tickle array */
struct ctdb_tcp_wire_array { struct ctdb_tcp_wire_array {
uint32_t num; uint32_t num;
struct ctdb_tcp_connection connections[1]; struct ctdb_connection connections[1];
}; };
/* the list of tcp tickles used by get/set tcp tickle list */ /* the list of tcp tickles used by get/set tcp tickle list */

8
ctdb/server/ctdb_control.c
View File

@ -383,15 +383,15 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
return ctdb_control_startup(ctdb, srcnode); return ctdb_control_startup(ctdb, srcnode);
case CTDB_CONTROL_TCP_ADD: case CTDB_CONTROL_TCP_ADD:
CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection)); CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
return ctdb_control_tcp_add(ctdb, indata, false); return ctdb_control_tcp_add(ctdb, indata, false);
case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE: case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection)); CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
return ctdb_control_tcp_add(ctdb, indata, true); return ctdb_control_tcp_add(ctdb, indata, true);
case CTDB_CONTROL_TCP_REMOVE: case CTDB_CONTROL_TCP_REMOVE:
CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection)); CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
return ctdb_control_tcp_remove(ctdb, indata); return ctdb_control_tcp_remove(ctdb, indata);
case CTDB_CONTROL_SET_TUNABLE: case CTDB_CONTROL_SET_TUNABLE:
@ -408,7 +408,7 @@ static int32_t ctdb_control_dispatch(struct ctdb_context *ctdb,
return ctdb_control_modflags(ctdb, indata); return ctdb_control_modflags(ctdb, indata);
case CTDB_CONTROL_KILL_TCP: case CTDB_CONTROL_KILL_TCP:
CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_tcp_connection)); CHECK_CONTROL_DATA_SIZE(sizeof(struct ctdb_connection));
return ctdb_control_kill_tcp(ctdb, indata); return ctdb_control_kill_tcp(ctdb, indata);
case CTDB_CONTROL_GET_TCP_TICKLE_LIST: case CTDB_CONTROL_GET_TCP_TICKLE_LIST:

110
ctdb/server/ctdb_takeover.c
View File

@ -299,7 +299,7 @@ struct ctdb_takeover_arp {
*/ */
struct ctdb_tcp_list { struct ctdb_tcp_list {
struct ctdb_tcp_list *prev, *next; struct ctdb_tcp_list *prev, *next;
struct ctdb_tcp_connection connection; struct ctdb_connection connection;
}; };
/* /*
@ -335,20 +335,20 @@ static void ctdb_control_send_arp(struct tevent_context *ev,
tcparray = arp->tcparray; tcparray = arp->tcparray;
if (tcparray) { if (tcparray) {
for (i=0;i<tcparray->num;i++) { for (i=0;i<tcparray->num;i++) {
struct ctdb_tcp_connection *tcon; struct ctdb_connection *tcon;
tcon = &tcparray->connections[i]; tcon = &tcparray->connections[i];
DEBUG(DEBUG_INFO,("sending tcp tickle ack for %u->%s:%u\n", DEBUG(DEBUG_INFO,("sending tcp tickle ack for %u->%s:%u\n",
(unsigned)ntohs(tcon->dst_addr.ip.sin_port), (unsigned)ntohs(tcon->dst.ip.sin_port),
ctdb_addr_to_str(&tcon->src_addr), ctdb_addr_to_str(&tcon->src),
(unsigned)ntohs(tcon->src_addr.ip.sin_port))); (unsigned)ntohs(tcon->src.ip.sin_port)));
ret = ctdb_sys_send_tcp( ret = ctdb_sys_send_tcp(
&tcon->src_addr, &tcon->src,
&tcon->dst_addr, &tcon->dst,
0, 0, 0); 0, 0, 0);
if (ret != 0) { if (ret != 0) {
DEBUG(DEBUG_CRIT,(__location__ " Failed to send tcp tickle ack for %s\n", 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)));
} }
} }
} }
@ -2815,7 +2815,7 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client); struct ctdb_client *client = reqid_find(ctdb->idr, client_id, struct ctdb_client);
struct ctdb_connection *tcp_sock = NULL; struct ctdb_connection *tcp_sock = NULL;
struct ctdb_tcp_list *tcp; struct ctdb_tcp_list *tcp;
struct ctdb_tcp_connection t; struct ctdb_connection t;
int ret; int ret;
TDB_DATA data; TDB_DATA data;
struct ctdb_client_ip *ip; struct ctdb_client_ip *ip;
@ -2876,13 +2876,13 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
tcp = talloc(client, struct ctdb_tcp_list); tcp = talloc(client, struct ctdb_tcp_list);
CTDB_NO_MEMORY(ctdb, tcp); CTDB_NO_MEMORY(ctdb, tcp);
tcp->connection.src_addr = tcp_sock->src; tcp->connection.src = tcp_sock->src;
tcp->connection.dst_addr = tcp_sock->dst; tcp->connection.dst = tcp_sock->dst;
DLIST_ADD(client->tcp_list, tcp); DLIST_ADD(client->tcp_list, tcp);
t.src_addr = tcp_sock->src; t.src = tcp_sock->src;
t.dst_addr = tcp_sock->dst; t.dst = tcp_sock->dst;
data.dptr = (uint8_t *)&t; data.dptr = (uint8_t *)&t;
data.dsize = sizeof(t); data.dsize = sizeof(t);
@ -2920,8 +2920,8 @@ int32_t ctdb_control_tcp_client(struct ctdb_context *ctdb, uint32_t client_id,
/* /*
find a tcp address on a list find a tcp address on a list
*/ */
static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array, static struct ctdb_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
struct ctdb_tcp_connection *tcp) struct ctdb_connection *tcp)
{ {
int i; int i;
@ -2930,8 +2930,8 @@ static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
} }
for (i=0;i<array->num;i++) { for (i=0;i<array->num;i++) {
if (ctdb_same_sockaddr(&array->connections[i].src_addr, &tcp->src_addr) && if (ctdb_same_sockaddr(&array->connections[i].src, &tcp->src) &&
ctdb_same_sockaddr(&array->connections[i].dst_addr, &tcp->dst_addr)) { ctdb_same_sockaddr(&array->connections[i].dst, &tcp->dst)) {
return &array->connections[i]; return &array->connections[i];
} }
} }
@ -2947,9 +2947,9 @@ static struct ctdb_tcp_connection *ctdb_tcp_find(struct ctdb_tcp_array *array,
*/ */
int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tcp_update_needed) 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_array *tcparray;
struct ctdb_tcp_connection tcp; struct ctdb_connection tcp;
struct ctdb_vnn *vnn; struct ctdb_vnn *vnn;
/* If we don't have public IPs, tickles are useless */ /* If we don't have public IPs, tickles are useless */
@ -2957,10 +2957,10 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
return 0; return 0;
} }
vnn = find_public_ip_vnn(ctdb, &p->dst_addr); vnn = find_public_ip_vnn(ctdb, &p->dst);
if (vnn == NULL) { if (vnn == NULL) {
DEBUG(DEBUG_INFO,(__location__ " got TCP_ADD control for an address which is not a public address '%s'\n", 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; return -1;
} }
@ -2975,11 +2975,11 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
vnn->tcp_array = tcparray; vnn->tcp_array = tcparray;
tcparray->num = 0; 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); CTDB_NO_MEMORY(ctdb, tcparray->connections);
tcparray->connections[tcparray->num].src_addr = p->src_addr; tcparray->connections[tcparray->num].src = p->src;
tcparray->connections[tcparray->num].dst_addr = p->dst_addr; tcparray->connections[tcparray->num].dst = p->dst;
tcparray->num++; tcparray->num++;
if (tcp_update_needed) { if (tcp_update_needed) {
@ -2990,29 +2990,29 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
/* Do we already have this tickle ?*/ /* Do we already have this tickle ?*/
tcp.src_addr = p->src_addr; tcp.src = p->src;
tcp.dst_addr = p->dst_addr; tcp.dst = p->dst;
if (ctdb_tcp_find(tcparray, &tcp) != NULL) { if (ctdb_tcp_find(tcparray, &tcp) != NULL) {
DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n", DEBUG(DEBUG_DEBUG,("Already had tickle info for %s:%u for vnn:%u\n",
ctdb_addr_to_str(&tcp.dst_addr), ctdb_addr_to_str(&tcp.dst),
ntohs(tcp.dst_addr.ip.sin_port), ntohs(tcp.dst.ip.sin_port),
vnn->pnn)); vnn->pnn));
return 0; return 0;
} }
/* A new tickle, we must add it to the array */ /* A new tickle, we must add it to the array */
tcparray->connections = talloc_realloc(tcparray, tcparray->connections, tcparray->connections = talloc_realloc(tcparray, tcparray->connections,
struct ctdb_tcp_connection, struct ctdb_connection,
tcparray->num+1); tcparray->num+1);
CTDB_NO_MEMORY(ctdb, tcparray->connections); CTDB_NO_MEMORY(ctdb, tcparray->connections);
tcparray->connections[tcparray->num].src_addr = p->src_addr; tcparray->connections[tcparray->num].src = p->src;
tcparray->connections[tcparray->num].dst_addr = p->dst_addr; tcparray->connections[tcparray->num].dst = p->dst;
tcparray->num++; tcparray->num++;
DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n", DEBUG(DEBUG_INFO,("Added tickle info for %s:%u from vnn %u\n",
ctdb_addr_to_str(&tcp.dst_addr), ctdb_addr_to_str(&tcp.dst),
ntohs(tcp.dst_addr.ip.sin_port), ntohs(tcp.dst.ip.sin_port),
vnn->pnn)); vnn->pnn));
if (tcp_update_needed) { if (tcp_update_needed) {
@ -3028,14 +3028,14 @@ int32_t ctdb_control_tcp_add(struct ctdb_context *ctdb, TDB_DATA indata, bool tc
clients managing that should tickled with an ACK when IP takeover is clients managing that should tickled with an ACK when IP takeover is
done 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_connection *tcpp;
struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst_addr); struct ctdb_vnn *vnn = find_public_ip_vnn(ctdb, &conn->dst);
if (vnn == NULL) { if (vnn == NULL) {
DEBUG(DEBUG_ERR,(__location__ " unable to find public address %s\n", 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; return;
} }
@ -3044,8 +3044,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
*/ */
if (vnn->tcp_array == NULL) { if (vnn->tcp_array == NULL) {
DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n", DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist (array is empty) %s:%u\n",
ctdb_addr_to_str(&conn->dst_addr), ctdb_addr_to_str(&conn->dst),
ntohs(conn->dst_addr.ip.sin_port))); ntohs(conn->dst.ip.sin_port)));
return; return;
} }
@ -3056,8 +3056,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
tcpp = ctdb_tcp_find(vnn->tcp_array, conn); tcpp = ctdb_tcp_find(vnn->tcp_array, conn);
if (tcpp == NULL) { if (tcpp == NULL) {
DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n", DEBUG(DEBUG_INFO,("Trying to remove tickle that doesnt exist %s:%u\n",
ctdb_addr_to_str(&conn->dst_addr), ctdb_addr_to_str(&conn->dst),
ntohs(conn->dst_addr.ip.sin_port))); ntohs(conn->dst.ip.sin_port)));
return; return;
} }
@ -3081,8 +3081,8 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
vnn->tcp_update_needed = true; vnn->tcp_update_needed = true;
DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n", DEBUG(DEBUG_INFO,("Removed tickle info for %s:%u\n",
ctdb_addr_to_str(&conn->src_addr), ctdb_addr_to_str(&conn->src),
ntohs(conn->src_addr.ip.sin_port))); ntohs(conn->src.ip.sin_port)));
} }
@ -3092,14 +3092,14 @@ static void ctdb_remove_tcp_connection(struct ctdb_context *ctdb, struct ctdb_tc
*/ */
int32_t ctdb_control_tcp_remove(struct ctdb_context *ctdb, TDB_DATA indata) 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 we don't have public IPs, tickles are useless */
if (ctdb->vnn == NULL) { if (ctdb->vnn == NULL) {
return 0; return 0;
} }
ctdb_remove_tcp_connection(ctdb, conn); ctdb_remove_connection(ctdb, conn);
return 0; return 0;
} }
@ -3136,7 +3136,7 @@ void ctdb_takeover_client_destructor_hook(struct ctdb_client *client)
while (client->tcp_list) { while (client->tcp_list) {
struct ctdb_tcp_list *tcp = client->tcp_list; struct ctdb_tcp_list *tcp = client->tcp_list;
DLIST_REMOVE(client->tcp_list, tcp); DLIST_REMOVE(client->tcp_list, tcp);
ctdb_remove_tcp_connection(client->ctdb, &tcp->connection); ctdb_remove_connection(client->ctdb, &tcp->connection);
} }
} }
@ -3731,9 +3731,9 @@ failed:
*/ */
int32_t ctdb_control_kill_tcp(struct ctdb_context *ctdb, TDB_DATA indata) 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);
} }
/* /*
@ -3760,7 +3760,7 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
/* verify that the size of data matches what we expect */ /* verify that the size of data matches what we expect */
if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list, if (indata.dsize < offsetof(struct ctdb_control_tcp_tickle_list,
tickles.connections) tickles.connections)
+ sizeof(struct ctdb_tcp_connection) + sizeof(struct ctdb_connection)
* list->tickles.num) { * list->tickles.num) {
DEBUG(DEBUG_ERR,("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; return -1;
@ -3786,11 +3786,11 @@ int32_t ctdb_control_set_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
tcparray->num = list->tickles.num; tcparray->num = list->tickles.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); CTDB_NO_MEMORY(ctdb, tcparray->connections);
memcpy(tcparray->connections, &list->tickles.connections[0], memcpy(tcparray->connections, &list->tickles.connections[0],
sizeof(struct ctdb_tcp_connection)*tcparray->num); sizeof(struct ctdb_connection)*tcparray->num);
/* We now have a new fresh tickle list array for this vnn */ /* We now have a new fresh tickle list array for this vnn */
vnn->tcp_array = tcparray; vnn->tcp_array = tcparray;
@ -3827,7 +3827,7 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list, outdata->dsize = offsetof(struct ctdb_control_tcp_tickle_list,
tickles.connections) tickles.connections)
+ sizeof(struct ctdb_tcp_connection) * num; + sizeof(struct ctdb_connection) * num;
outdata->dptr = talloc_size(outdata, outdata->dsize); outdata->dptr = talloc_size(outdata, outdata->dsize);
CTDB_NO_MEMORY(ctdb, outdata->dptr); CTDB_NO_MEMORY(ctdb, outdata->dptr);
@ -3837,7 +3837,7 @@ int32_t ctdb_control_get_tcp_tickle_list(struct ctdb_context *ctdb, TDB_DATA ind
list->tickles.num = num; list->tickles.num = num;
if (num) { if (num) {
memcpy(&list->tickles.connections[0], tcparray->connections, memcpy(&list->tickles.connections[0], tcparray->connections,
sizeof(struct ctdb_tcp_connection) * num); sizeof(struct ctdb_connection) * num);
} }
return 0; return 0;
@ -3863,7 +3863,7 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
data.dsize = offsetof(struct ctdb_control_tcp_tickle_list, data.dsize = offsetof(struct ctdb_control_tcp_tickle_list,
tickles.connections) + tickles.connections) +
sizeof(struct ctdb_tcp_connection) * num; sizeof(struct ctdb_connection) * num;
data.dptr = talloc_size(ctdb, data.dsize); data.dptr = talloc_size(ctdb, data.dsize);
CTDB_NO_MEMORY(ctdb, data.dptr); CTDB_NO_MEMORY(ctdb, data.dptr);
@ -3871,7 +3871,7 @@ static int ctdb_send_set_tcp_tickles_for_ip(struct ctdb_context *ctdb,
list->addr = *addr; list->addr = *addr;
list->tickles.num = num; list->tickles.num = num;
if (tcparray) { if (tcparray) {
memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_tcp_connection) * num); memcpy(&list->tickles.connections[0], tcparray->connections, sizeof(struct ctdb_connection) * num);
} }
ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0, ret = ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL, 0,

40
ctdb/tools/ctdb.c
View File

@ -1615,7 +1615,7 @@ static int control_recmaster(struct ctdb_context *ctdb, int argc, const char **a
*/ */
static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **argv) static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
{ {
struct ctdb_tcp_connection t; struct ctdb_connection t;
TDB_DATA data; TDB_DATA data;
int ret; int ret;
@ -1625,11 +1625,11 @@ static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **
usage(); usage();
} }
if (parse_ip_port(argv[0], &t.src_addr) == 0) { if (parse_ip_port(argv[0], &t.src) == 0) {
DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0])); DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
return -1; return -1;
} }
if (parse_ip_port(argv[1], &t.dst_addr) == 0) { if (parse_ip_port(argv[1], &t.dst) == 0) {
DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1])); DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
return -1; return -1;
} }
@ -1654,7 +1654,7 @@ static int control_add_tickle(struct ctdb_context *ctdb, int argc, const char **
*/ */
static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **argv) static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **argv)
{ {
struct ctdb_tcp_connection t; struct ctdb_connection t;
TDB_DATA data; TDB_DATA data;
int ret; int ret;
@ -1664,11 +1664,11 @@ static int control_del_tickle(struct ctdb_context *ctdb, int argc, const char **
usage(); usage();
} }
if (parse_ip_port(argv[0], &t.src_addr) == 0) { if (parse_ip_port(argv[0], &t.src) == 0) {
DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0])); DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[0]));
return -1; return -1;
} }
if (parse_ip_port(argv[1], &t.dst_addr) == 0) { if (parse_ip_port(argv[1], &t.dst) == 0) {
DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1])); DEBUG(DEBUG_ERR,("Wrongly formed ip address '%s'\n", argv[1]));
return -1; return -1;
} }
@ -1722,21 +1722,21 @@ static int control_get_tickles(struct ctdb_context *ctdb, int argc, const char *
if (options.machinereadable){ if (options.machinereadable){
printm(":source ip:port:destination ip:port:\n"); printm(":source ip:port:destination ip:port:\n");
for (i=0;i<list->tickles.num;i++) { for (i=0;i<list->tickles.num;i++) {
if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) { if (port && port != ntohs(list->tickles.connections[i].dst.ip.sin_port)) {
continue; continue;
} }
printm(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port)); printm(":%s:%u", ctdb_addr_to_str(&list->tickles.connections[i].src), ntohs(list->tickles.connections[i].src.ip.sin_port));
printm(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)); printm(":%s:%u:\n", ctdb_addr_to_str(&list->tickles.connections[i].dst), ntohs(list->tickles.connections[i].dst.ip.sin_port));
} }
} else { } else {
printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr)); printf("Tickles for ip:%s\n", ctdb_addr_to_str(&list->addr));
printf("Num tickles:%u\n", list->tickles.num); printf("Num tickles:%u\n", list->tickles.num);
for (i=0;i<list->tickles.num;i++) { for (i=0;i<list->tickles.num;i++) {
if (port && port != ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)) { if (port && port != ntohs(list->tickles.connections[i].dst.ip.sin_port)) {
continue; continue;
} }
printf("SRC: %s:%u ", ctdb_addr_to_str(&list->tickles.connections[i].src_addr), ntohs(list->tickles.connections[i].src_addr.ip.sin_port)); printf("SRC: %s:%u ", ctdb_addr_to_str(&list->tickles.connections[i].src), ntohs(list->tickles.connections[i].src.ip.sin_port));
printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst_addr), ntohs(list->tickles.connections[i].dst_addr.ip.sin_port)); printf("DST: %s:%u\n", ctdb_addr_to_str(&list->tickles.connections[i].dst), ntohs(list->tickles.connections[i].dst.ip.sin_port));
} }
} }
@ -2619,7 +2619,7 @@ static int control_delip(struct ctdb_context *ctdb, int argc, const char **argv)
static int kill_tcp_from_file(struct ctdb_context *ctdb, static int kill_tcp_from_file(struct ctdb_context *ctdb,
int argc, const char **argv) int argc, const char **argv)
{ {
struct ctdb_tcp_connection *killtcp; struct ctdb_connection *killtcp;
int max_entries, current, i; int max_entries, current, i;
struct timeval timeout; struct timeval timeout;
char line[128], src[128], dst[128]; char line[128], src[128], dst[128];
@ -2656,19 +2656,19 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
if (current >= max_entries) { if (current >= max_entries) {
max_entries += 1024; max_entries += 1024;
killtcp = talloc_realloc(ctdb, killtcp, killtcp = talloc_realloc(ctdb, killtcp,
struct ctdb_tcp_connection, struct ctdb_connection,
max_entries); max_entries);
CTDB_NO_MEMORY(ctdb, killtcp); CTDB_NO_MEMORY(ctdb, killtcp);
} }
if (!parse_ip_port(src, &killtcp[current].src_addr)) { if (!parse_ip_port(src, &killtcp[current].src)) {
DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n", DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
linenum, src)); linenum, src));
talloc_free(killtcp); talloc_free(killtcp);
return -1; return -1;
} }
if (!parse_ip_port(dst, &killtcp[current].dst_addr)) { if (!parse_ip_port(dst, &killtcp[current].dst)) {
DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n", DEBUG(DEBUG_ERR, ("Bad IP:port on line [%d]: '%s'\n",
linenum, dst)); linenum, dst));
talloc_free(killtcp); talloc_free(killtcp);
@ -2686,7 +2686,7 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
for (i = 0; i < current; i++) { for (i = 0; i < current; i++) {
data.dsize = sizeof(struct ctdb_tcp_connection); data.dsize = sizeof(struct ctdb_connection);
data.dptr = (unsigned char *)&killtcp[i]; data.dptr = (unsigned char *)&killtcp[i];
timeout = TIMELIMIT(); timeout = TIMELIMIT();
@ -2722,7 +2722,7 @@ static int kill_tcp_from_file(struct ctdb_context *ctdb,
static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv) static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
{ {
int ret; int ret;
struct ctdb_tcp_connection killtcp; struct ctdb_connection killtcp;
assert_single_node_only(); assert_single_node_only();
@ -2734,12 +2734,12 @@ static int kill_tcp(struct ctdb_context *ctdb, int argc, const char **argv)
usage(); usage();
} }
if (!parse_ip_port(argv[0], &killtcp.src_addr)) { if (!parse_ip_port(argv[0], &killtcp.src)) {
DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[0])); DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[0]));
return -1; return -1;
} }
if (!parse_ip_port(argv[1], &killtcp.dst_addr)) { if (!parse_ip_port(argv[1], &killtcp.dst)) {
DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[1])); DEBUG(DEBUG_ERR, ("Bad IP:port '%s'\n", argv[1]));
return -1; return -1;
} }