#include "serverid.h"
#include "ctdbd_conn.h"
#include "system/select.h"
-#include "lib/sys_rw_data.h"
+#include "lib/util/sys_rw_data.h"
#include "lib/util/iov_buf.h"
#include "messages.h"
/* paths to these include files come from --with-ctdb= in configure */
-#include "ctdb.h"
#include "ctdb_private.h"
struct ctdbd_srvid_cb {
}
static int ctdbd_msg_call_back(struct ctdbd_connection *conn,
- struct ctdb_req_message *msg)
+ struct ctdb_req_message_old *msg)
{
size_t msg_len;
size_t i, num_callbacks;
msg_len = msg->hdr.length;
- if (msg_len < offsetof(struct ctdb_req_message, data)) {
+ if (msg_len < offsetof(struct ctdb_req_message_old, data)) {
DEBUG(10, ("%s: len %u too small\n", __func__,
(unsigned)msg_len));
return 0;
}
- msg_len -= offsetof(struct ctdb_req_message, data);
+ msg_len -= offsetof(struct ctdb_req_message_old, data);
if (msg_len < msg->datalen) {
DEBUG(10, ("%s: msg_len=%u < msg->datalen=%u\n", __func__,
{
int32_t cstatus=-1;
TDB_DATA outdata;
- struct ctdb_node_map *m;
+ struct ctdb_node_map_old *m;
uint32_t failure_flags;
bool ok = false;
int i, ret;
return false;
}
- m = (struct ctdb_node_map *)outdata.dptr;
+ m = (struct ctdb_node_map_old *)outdata.dptr;
for (i=0; i<m->num; i++) {
if (vnn == m->nodes[i].pnn) {
ssize_t nread;
if (timeout != -1) {
- ret = poll_one_fd(fd, POLLIN, timeout, &revents);
+ ret = poll_intr_one_fd(fd, POLLIN, timeout, &revents);
if (ret == -1) {
return errno;
}
ctdb_packet_dump(hdr);
if (hdr->operation == CTDB_REQ_MESSAGE) {
- struct ctdb_req_message *msg = (struct ctdb_req_message *)hdr;
+ struct ctdb_req_message_old *msg = (struct ctdb_req_message_old *)hdr;
if (conn->msg_ctx == NULL) {
DEBUG(1, ("Got a message without having a msg ctx, "
conn->sockname = talloc_strdup(conn, sockname);
if (conn->sockname == NULL) {
- DBG_ERR("%s: talloc failed\n", __func__);
+ DBG_ERR("talloc failed\n");
ret = ENOMEM;
goto fail;
}
static int ctdb_handle_message(struct ctdbd_connection *conn,
struct ctdb_req_header *hdr)
{
- struct ctdb_req_message *msg;
+ struct ctdb_req_message_old *msg;
if (hdr->operation != CTDB_REQ_MESSAGE) {
DEBUG(0, ("Received async msg of type %u, discarding\n",
return EINVAL;
}
- msg = (struct ctdb_req_message *)hdr;
+ msg = (struct ctdb_req_message_old *)hdr;
ctdbd_msg_call_back(conn, msg);
*/
int ctdbd_register_msg_ctx(struct ctdbd_connection *conn,
- struct messaging_context *msg_ctx)
+ struct messaging_context *msg_ctx,
+ struct tevent_context *ev)
{
SMB_ASSERT(conn->msg_ctx == NULL);
SMB_ASSERT(conn->fde == NULL);
- if (!(conn->fde = tevent_add_fd(messaging_tevent_context(msg_ctx),
- conn,
- conn->fd,
- TEVENT_FD_READ,
- ctdbd_socket_handler,
- conn))) {
+ conn->fde = tevent_add_fd(ev, conn, conn->fd, TEVENT_FD_READ,
+ ctdbd_socket_handler, conn);
+ if (conn->fde == NULL) {
DEBUG(0, ("event_add_fd failed\n"));
return ENOMEM;
}
uint32_t dst_vnn, uint64_t dst_srvid,
const struct iovec *iov, int iovlen)
{
- struct ctdb_req_message r;
+ struct ctdb_req_message_old r;
struct iovec iov2[iovlen+1];
size_t buflen = iov_buflen(iov, iovlen);
ssize_t nwritten;
- r.hdr.length = offsetof(struct ctdb_req_message, data) + buflen;
+ r.hdr.length = offsetof(struct ctdb_req_message_old, data) + buflen;
r.hdr.ctdb_magic = CTDB_MAGIC;
r.hdr.ctdb_version = CTDB_PROTOCOL;
r.hdr.generation = 1;
ctdb_packet_dump(&r.hdr);
iov2[0].iov_base = &r;
- iov2[0].iov_len = offsetof(struct ctdb_req_message, data);
+ iov2[0].iov_len = offsetof(struct ctdb_req_message_old, data);
memcpy(&iov2[1], iov, iovlen * sizeof(struct iovec));
nwritten = write_data_iov(conn->fd, iov2, iovlen+1);
TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
int *cstatus)
{
- struct ctdb_req_control req;
+ struct ctdb_req_control_old req;
struct ctdb_req_header *hdr;
- struct ctdb_reply_control *reply = NULL;
+ struct ctdb_reply_control_old *reply = NULL;
struct iovec iov[2];
ssize_t nwritten;
int ret;
ZERO_STRUCT(req);
- req.hdr.length = offsetof(struct ctdb_req_control, data) + data.dsize;
+ req.hdr.length = offsetof(struct ctdb_req_control_old, data) + data.dsize;
req.hdr.ctdb_magic = CTDB_MAGIC;
req.hdr.ctdb_version = CTDB_PROTOCOL;
req.hdr.operation = CTDB_REQ_CONTROL;
ctdb_packet_dump(&req.hdr);
iov[0].iov_base = &req;
- iov[0].iov_len = offsetof(struct ctdb_req_control, data);
+ iov[0].iov_len = offsetof(struct ctdb_req_control_old, data);
iov[1].iov_base = data.dptr;
iov[1].iov_len = data.dsize;
TALLOC_FREE(hdr);
return EIO;
}
- reply = (struct ctdb_reply_control *)hdr;
+ reply = (struct ctdb_reply_control_old *)hdr;
if (outdata) {
if (!(outdata->dptr = (uint8_t *)talloc_memdup(
}
for (i=0; i<num_pids; i++) {
- struct ctdb_req_control req;
+ struct ctdb_req_control_old req;
pid_t pid;
struct iovec iov[2];
ssize_t nwritten;
(int)pids[i].vnn, (int)pid,
(int)reqids[i]));
- req.hdr.length = offsetof(struct ctdb_req_control, data);
+ req.hdr.length = offsetof(struct ctdb_req_control_old, data);
req.hdr.length += sizeof(pid);
req.hdr.ctdb_magic = CTDB_MAGIC;
req.hdr.ctdb_version = CTDB_PROTOCOL;
ctdb_packet_dump(&req.hdr);
iov[0].iov_base = &req;
- iov[0].iov_len = offsetof(struct ctdb_req_control, data);
+ iov[0].iov_len = offsetof(struct ctdb_req_control_old, data);
iov[1].iov_base = &pid;
iov[1].iov_len = sizeof(pid);
while (num_received < num_pids) {
struct ctdb_req_header *hdr;
- struct ctdb_reply_control *reply;
+ struct ctdb_reply_control_old *reply;
uint32_t reqid;
int ret;
DEBUG(10, ("Received invalid reply\n"));
goto fail;
}
- reply = (struct ctdb_reply_control *)hdr;
+ reply = (struct ctdb_reply_control_old *)hdr;
reqid = reply->hdr.reqid;
*/
int ctdbd_migrate(struct ctdbd_connection *conn, uint32_t db_id, TDB_DATA key)
{
- struct ctdb_req_call req;
+ struct ctdb_req_call_old req;
struct ctdb_req_header *hdr;
struct iovec iov[2];
ssize_t nwritten;
ZERO_STRUCT(req);
- req.hdr.length = offsetof(struct ctdb_req_call, data) + key.dsize;
+ req.hdr.length = offsetof(struct ctdb_req_call_old, data) + key.dsize;
req.hdr.ctdb_magic = CTDB_MAGIC;
req.hdr.ctdb_version = CTDB_PROTOCOL;
req.hdr.operation = CTDB_REQ_CALL;
ctdb_packet_dump(&req.hdr);
iov[0].iov_base = &req;
- iov[0].iov_len = offsetof(struct ctdb_req_call, data);
+ iov[0].iov_len = offsetof(struct ctdb_req_call_old, data);
iov[1].iov_base = key.dptr;
iov[1].iov_len = key.dsize;
void *private_data),
void *private_data)
{
- struct ctdb_req_call req;
+ struct ctdb_req_call_old req;
struct ctdb_req_header *hdr = NULL;
- struct ctdb_reply_call *reply;
+ struct ctdb_reply_call_old *reply;
struct iovec iov[2];
ssize_t nwritten;
uint32_t flags;
ZERO_STRUCT(req);
- req.hdr.length = offsetof(struct ctdb_req_call, data) + key.dsize;
+ req.hdr.length = offsetof(struct ctdb_req_call_old, data) + key.dsize;
req.hdr.ctdb_magic = CTDB_MAGIC;
req.hdr.ctdb_version = CTDB_PROTOCOL;
req.hdr.operation = CTDB_REQ_CALL;
req.keylen = key.dsize;
iov[0].iov_base = &req;
- iov[0].iov_len = offsetof(struct ctdb_req_call, data);
+ iov[0].iov_len = offsetof(struct ctdb_req_call_old, data);
iov[1].iov_base = key.dptr;
iov[1].iov_len = key.dsize;
ret = EIO;
goto fail;
}
- reply = (struct ctdb_reply_call *)hdr;
+ reply = (struct ctdb_reply_call_old *)hdr;
if (reply->datalen == 0) {
/*
while (True) {
struct ctdb_req_header *hdr = NULL;
- struct ctdb_req_message *m;
- struct ctdb_rec_data *d;
+ struct ctdb_req_message_old *m;
+ struct ctdb_rec_data_old *d;
ret = ctdb_read_packet(conn->fd, conn->timeout, conn, &hdr);
if (ret != 0) {
return EIO;
}
- m = (struct ctdb_req_message *)hdr;
- d = (struct ctdb_rec_data *)&m->data[0];
+ m = (struct ctdb_req_message_old *)hdr;
+ d = (struct ctdb_rec_data_old *)&m->data[0];
if (m->datalen < sizeof(uint32_t) || m->datalen != d->length) {
DEBUG(0, ("Got invalid traverse data of length %d\n",
(int)m->datalen));
int ctdb_watch_us(struct ctdbd_connection *conn)
{
- struct ctdb_client_notify_register reg_data;
+ struct ctdb_notify_data_old reg_data;
size_t struct_len;
int ret;
int cstatus;
reg_data.len = 1;
reg_data.notify_data[0] = 0;
- struct_len = offsetof(struct ctdb_client_notify_register,
+ struct_len = offsetof(struct ctdb_notify_data_old,
notify_data) + reg_data.len;
ret = ctdbd_control_local(
git.samba.org / obnox / samba / samba-obnox.git / blobdiff