source: vendor/current/ctdb/protocol/protocol_call.c

/*
   CTDB protocol marshalling

   Copyright (C) Amitay Isaacs  2015

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

#include "replace.h"
#include "system/network.h"

#include <talloc.h>
#include <tdb.h>

#include "protocol.h"
#include "protocol_api.h"
#include "protocol_private.h"

struct ctdb_req_call_wire {
        struct ctdb_req_header hdr;
        uint32_t flags;
        uint32_t db_id;
        uint32_t callid;
        uint32_t hopcount;
        uint32_t keylen;
        uint32_t calldatalen;
        uint8_t data[1]; /* key[] followed by calldata[] */
};

struct ctdb_reply_call_wire {
        struct ctdb_req_header hdr;
        uint32_t status;
        uint32_t datalen;
        uint8_t  data[1];
};

struct ctdb_reply_error_wire {
        struct ctdb_req_header hdr;
        uint32_t status;
        uint32_t msglen;
        uint8_t  msg[1];
};

struct ctdb_req_dmaster_wire {
        struct ctdb_req_header hdr;
        uint32_t db_id;
        uint64_t rsn;
        uint32_t dmaster;
        uint32_t keylen;
        uint32_t datalen;
        uint8_t  data[1];
};

struct ctdb_reply_dmaster_wire {
        struct ctdb_req_header hdr;
        uint32_t db_id;
        uint64_t rsn;
        uint32_t keylen;
        uint32_t datalen;
        uint8_t  data[1];
};

int ctdb_req_call_push(struct ctdb_req_header *h, struct ctdb_req_call *c,
                       TALLOC_CTX *mem_ctx, uint8_t **pkt, size_t *pkt_len)
{
        struct ctdb_req_call_wire *wire;
        uint8_t *buf;
        size_t length, buflen;
        int ret;

        if (c->key.dsize == 0) {
                return EINVAL;
        }

        length = offsetof(struct ctdb_req_call_wire, data) +
                 c->key.dsize + c->calldata.dsize;

        ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
        if (ret != 0) {
                return ret;
        }

        wire = (struct ctdb_req_call_wire *)buf;

        h->length = buflen;
        memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));

        wire->flags = c->flags;
        wire->db_id = c->db_id;
        wire->callid = c->callid;
        wire->hopcount = c->hopcount;
        wire->keylen = c->key.dsize;
        wire->calldatalen = c->calldata.dsize;
        memcpy(wire->data, c->key.dptr, c->key.dsize);
        if (c->calldata.dsize > 0) {
                memcpy(wire->data + c->key.dsize, c->calldata.dptr,
                       c->calldata.dsize);
        }

        *pkt = buf;
        *pkt_len = buflen;
        return 0;
}

int ctdb_req_call_pull(uint8_t *pkt, size_t pkt_len,
                       struct ctdb_req_header *h,
                       TALLOC_CTX *mem_ctx,
                       struct ctdb_req_call *c)
{
        struct ctdb_req_call_wire *wire;
        size_t length;

        length = offsetof(struct ctdb_req_call_wire, data);
        if (pkt_len < length) {
                return EMSGSIZE;
        }

        wire = (struct ctdb_req_call_wire *)pkt;

        if (pkt_len < length + wire->keylen + wire->calldatalen) {
                return EMSGSIZE;
        }

        memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));

        c->flags = wire->flags;
        c->db_id = wire->db_id;
        c->callid = wire->callid;
        c->hopcount = wire->hopcount;
        c->key.dsize = wire->keylen;
        c->key.dptr = talloc_memdup(mem_ctx, wire->data, wire->keylen);
        if (c->key.dptr == NULL) {
                return ENOMEM;
        }
        c->calldata.dsize = wire->calldatalen;
        if (wire->calldatalen > 0) {
                c->calldata.dptr = talloc_memdup(mem_ctx,
                                                 wire->data + wire->keylen,
                                                 wire->calldatalen);
                if (c->calldata.dptr == NULL) {
                        talloc_free(c->key.dptr);
                        return ENOMEM;
                }
        }

        return 0;
}

int ctdb_reply_call_push(struct ctdb_req_header *h, struct ctdb_reply_call *c,
                         TALLOC_CTX *mem_ctx, uint8_t **pkt, size_t *pkt_len)
{
        struct ctdb_reply_call_wire *wire;
        uint8_t *buf;
        size_t length, buflen;
        int ret;

        length = offsetof(struct ctdb_reply_call_wire, data) + c->data.dsize;

        ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
        if (ret != 0) {
                return ret;
        }

        wire = (struct ctdb_reply_call_wire *)buf;

        h->length = buflen;
        memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));

        wire->status = c->status;
        wire->datalen = c->data.dsize;
        if (c->data.dsize > 0) {
                memcpy(wire->data, c->data.dptr, c->data.dsize);
        }

        *pkt = buf;
        *pkt_len = buflen;
        return 0;
}

int ctdb_reply_call_pull(uint8_t *pkt, size_t pkt_len,
                         struct ctdb_req_header *h,
                         TALLOC_CTX *mem_ctx,
                         struct ctdb_reply_call *c)
{
        struct ctdb_reply_call_wire *wire;
        size_t length;

        length = offsetof(struct ctdb_reply_call_wire, data);
        if (pkt_len < length) {
                return EMSGSIZE;
        }

        wire = (struct ctdb_reply_call_wire *)pkt;

        if (pkt_len < length + wire->datalen) {
                return EMSGSIZE;
        }

        memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));

        c->status = wire->status;
        c->data.dsize = wire->datalen;
        if (wire->datalen > 0) {
                c->data.dptr = talloc_memdup(mem_ctx, wire->data,
                                             wire->datalen);
                if (c->data.dptr == NULL) {
                        return ENOMEM;
                }
        }

        return 0;
}

int ctdb_reply_error_push(struct ctdb_req_header *h, struct ctdb_reply_error *c,
                          TALLOC_CTX *mem_ctx, uint8_t **pkt, size_t *pkt_len)
{
        struct ctdb_reply_error_wire *wire;
        uint8_t *buf;
        size_t length, buflen;
        int ret;

        length = offsetof(struct ctdb_reply_error_wire, msg) + c->msg.dsize;

        ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
        if (ret != 0) {
                return ret;
        }

        wire = (struct ctdb_reply_error_wire *)buf;

        h->length = buflen;
        memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));

        wire->status = c->status;
        wire->msglen = c->msg.dsize;
        if (c->msg.dsize > 0) {
                memcpy(wire->msg, c->msg.dptr, c->msg.dsize);
        }

        *pkt = buf;
        *pkt_len = buflen;
        return 0;
}

int ctdb_reply_error_pull(uint8_t *pkt, size_t pkt_len,
                          struct ctdb_req_header *h,
                          TALLOC_CTX *mem_ctx,
                          struct ctdb_reply_error *c)
{
        struct ctdb_reply_error_wire *wire;
        size_t length;

        length = offsetof(struct ctdb_reply_error_wire, msg);
        if (pkt_len < length) {
                return EMSGSIZE;
        }

        wire = (struct ctdb_reply_error_wire *)pkt;

        if (pkt_len < length + wire->msglen) {
                return EMSGSIZE;
        }

        memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));

        c->status = wire->status;
        c->msg.dsize = wire->msglen;
        if (wire->msglen > 0) {
                c->msg.dptr = talloc_memdup(mem_ctx, wire->msg, wire->msglen);
                if (c->msg.dptr == NULL) {
                        return ENOMEM;
                }
        }

        return 0;
}

int ctdb_req_dmaster_push(struct ctdb_req_header *h, struct ctdb_req_dmaster *c,
                          TALLOC_CTX *mem_ctx, uint8_t **pkt, size_t *pkt_len)
{
        struct ctdb_req_dmaster_wire *wire;
        uint8_t *buf;
        size_t length, buflen;
        int ret;

        length = offsetof(struct ctdb_req_dmaster_wire, data) +
                 c->key.dsize + c->data.dsize;

        ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
        if (ret != 0) {
                return ret;
        }

        wire = (struct ctdb_req_dmaster_wire *)buf;

        h->length = buflen;
        memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));

        wire->db_id = c->db_id;
        wire->rsn = c->rsn;
        wire->dmaster = c->dmaster;
        wire->keylen = c->key.dsize;
        if (c->key.dsize > 0) {
                memcpy(wire->data, c->key.dptr, c->key.dsize);
        }
        wire->datalen = c->data.dsize;
        if (c->data.dsize > 0) {
                memcpy(wire->data + c->key.dsize, c->data.dptr, c->data.dsize);
        }

        *pkt = buf;
        *pkt_len = buflen;
        return 0;
}

int ctdb_req_dmaster_pull(uint8_t *pkt, size_t pkt_len,
                          struct ctdb_req_header *h,
                          TALLOC_CTX *mem_ctx,
                          struct ctdb_req_dmaster *c)
{
        struct ctdb_req_dmaster_wire *wire;
        size_t length;

        length = offsetof(struct ctdb_req_dmaster_wire, data);
        if (pkt_len < length) {
                return EMSGSIZE;
        }

        wire = (struct ctdb_req_dmaster_wire *)pkt;

        if (pkt_len < length + wire->keylen + wire->datalen) {
                return EMSGSIZE;
        }

        memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));

        c->db_id = wire->db_id;
        c->rsn = wire->rsn;
        c->dmaster = wire->dmaster;
        c->key.dsize = wire->keylen;
        c->key.dptr = talloc_memdup(mem_ctx, wire->data, wire->keylen);
        if (c->key.dptr == NULL) {
                return ENOMEM;
        }
        c->data.dsize = wire->datalen;
        if (wire->datalen > 0) {
                c->data.dptr = talloc_memdup(mem_ctx, wire->data + wire->keylen,
                                             wire->datalen);
                if (c->data.dptr == NULL) {
                        talloc_free(c->key.dptr);
                        return ENOMEM;
                }
        }

        return 0;
}

int ctdb_reply_dmaster_push(struct ctdb_req_header *h,
                            struct ctdb_reply_dmaster *c,
                            TALLOC_CTX *mem_ctx, uint8_t **pkt, size_t *pkt_len)
{
        struct ctdb_reply_dmaster_wire *wire;
        uint8_t *buf;
        size_t length, buflen;
        int ret;

        length = offsetof(struct ctdb_reply_dmaster_wire, data) +
                 c->key.dsize + c->data.dsize;

        ret = allocate_pkt(mem_ctx, length, &buf, &buflen);
        if (ret != 0) {
                return ret;
        }

        wire = (struct ctdb_reply_dmaster_wire *)buf;

        h->length = buflen;
        memcpy(&wire->hdr, h, sizeof(struct ctdb_req_header));

        wire->db_id = c->db_id;
        wire->rsn = c->rsn;
        wire->keylen = c->key.dsize;
        if (c->key.dsize > 0) {
                memcpy(wire->data, c->key.dptr, c->key.dsize);
        }
        wire->datalen = c->data.dsize;
        if (c->data.dsize > 0) {
                memcpy(wire->data + c->key.dsize, c->data.dptr, c->data.dsize);
        }

        *pkt = buf;
        *pkt_len = buflen;
        return 0;
}

int ctdb_reply_dmaster_pull(uint8_t *pkt, size_t pkt_len,
                            struct ctdb_req_header *h,
                            TALLOC_CTX *mem_ctx,
                            struct ctdb_reply_dmaster *c)
{
        struct ctdb_reply_dmaster_wire *wire;
        size_t length;

        length = offsetof(struct ctdb_reply_dmaster_wire, data);
        if (pkt_len < length) {
                return EMSGSIZE;
        }

        wire = (struct ctdb_reply_dmaster_wire *)pkt;

        if (pkt_len < length + wire->keylen + wire->datalen) {
                return EMSGSIZE;
        }

        memcpy(h, &wire->hdr, sizeof(struct ctdb_req_header));

        c->db_id = wire->db_id;
        c->rsn = wire->rsn;
        c->key.dsize = wire->keylen;
        c->key.dptr = talloc_memdup(mem_ctx, wire->data, wire->keylen);
        if (c->key.dptr == NULL) {
                return ENOMEM;
        }
        c->data.dsize = wire->datalen;
        if (wire->datalen > 0) {
                c->data.dptr = talloc_memdup(mem_ctx, wire->data + wire->keylen,
                                             wire->datalen);
                if (c->data.dptr == NULL) {
                        talloc_free(c->key.dptr);
                        return ENOMEM;
                }
        }

        return 0;
}