static int addr_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct rtnl_addr *dst = nl_object_priv(_dst);
struct rtnl_addr *src = nl_object_priv(_src);
if (src->a_peer)
if (!(dst->a_peer = nl_addr_clone(src->a_peer)))
goto errout;
if (src->a_local)
if (!(dst->a_local = nl_addr_clone(src->a_local)))
goto errout;
if (src->a_bcast)
if (!(dst->a_bcast = nl_addr_clone(src->a_bcast)))
goto errout;
if (src->a_anycast)
if (!(dst->a_anycast = nl_addr_clone(src->a_anycast)))
goto errout;
if (src->a_multicast)
if (!(dst->a_multicast = nl_addr_clone(src->a_multicast)))
goto errout;
return 0;
errout:
return nl_get_errno();
}
static int rule_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct rtnl_rule *dst = nl_object_priv(_dst);
struct rtnl_rule *src = nl_object_priv(_src);
if (src->r_src)
if (!(dst->r_src = nl_addr_clone(src->r_src)))
return -NLE_NOMEM;
if (src->r_dst)
if (!(dst->r_dst = nl_addr_clone(src->r_dst)))
return -NLE_NOMEM;
return 0;
}
static int idiagnl_msg_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct idiagnl_msg *dst = (struct idiagnl_msg *) _dst;
struct idiagnl_msg *src = (struct idiagnl_msg *) _src;
if (src->idiag_src)
if (!(dst->idiag_src = nl_addr_clone(src->idiag_src)))
return -NLE_NOMEM;
if (src->idiag_dst)
if (!(dst->idiag_dst = nl_addr_clone(src->idiag_dst)))
return -NLE_NOMEM;
return 0;
}
static int rule_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct rtnl_rule *dst = nl_object_priv(_dst);
struct rtnl_rule *src = nl_object_priv(_src);
if (src->r_src)
if (!(dst->r_src = nl_addr_clone(src->r_src)))
goto errout;
if (src->r_dst)
if (!(dst->r_dst = nl_addr_clone(src->r_dst)))
goto errout;
return 0;
errout:
return nl_get_errno();
}
TNlAddr &TNlAddr::operator=(const TNlAddr &other) {
if (this != &other) {
nl_addr_put(Addr);
if (other.Addr)
Addr = nl_addr_clone(other.Addr);
else
Addr = nullptr;
}
return *this;
}
static int request_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct flnl_request *dst = nl_object_priv(_dst);
struct flnl_request *src = nl_object_priv(_src);
if (src->lr_addr)
if (!(dst->lr_addr = nl_addr_clone(src->lr_addr)))
return -NLE_NOMEM;
return 0;
}
static int xfrm_ae_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct xfrmnl_ae* dst = nl_object_priv(_dst);
struct xfrmnl_ae* src = nl_object_priv(_src);
if (src->sa_id.daddr)
if ((dst->sa_id.daddr = nl_addr_clone (src->sa_id.daddr)) == NULL)
return -NLE_NOMEM;
if (src->saddr)
if ((dst->saddr = nl_addr_clone (src->saddr)) == NULL)
return -NLE_NOMEM;
if (src->replay_state_esn)
{
uint32_t len = sizeof (struct xfrmnl_replay_state_esn) + (sizeof (uint32_t) * src->replay_state_esn->bmp_len);
if ((dst->replay_state_esn = (struct xfrmnl_replay_state_esn*)calloc (1, len)) == NULL)
return -NLE_NOMEM;
memcpy (dst->replay_state_esn, dst->replay_state_esn, len);
}
return 0;
}
static int ct_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct nfnl_ct *dst = (struct nfnl_ct *) _dst;
struct nfnl_ct *src = (struct nfnl_ct *) _src;
struct nl_addr *addr;
if (src->ct_orig.src) {
addr = nl_addr_clone(src->ct_orig.src);
if (!addr)
return -NLE_NOMEM;
dst->ct_orig.src = addr;
}
if (src->ct_orig.dst) {
addr = nl_addr_clone(src->ct_orig.dst);
if (!addr)
return -NLE_NOMEM;
dst->ct_orig.dst = addr;
}
if (src->ct_repl.src) {
addr = nl_addr_clone(src->ct_repl.src);
if (!addr)
return -NLE_NOMEM;
dst->ct_repl.src = addr;
}
if (src->ct_repl.dst) {
addr = nl_addr_clone(src->ct_repl.dst);
if (!addr)
return -NLE_NOMEM;
dst->ct_repl.dst = addr;
}
return 0;
}
static void get_neigh_cb_event(struct nl_object *obj, void *arg)
{
struct get_neigh_handler *neigh_handler =
(struct get_neigh_handler *)arg;
/* assumed serilized callback (no parallel execution of function) */
if (nl_object_match_filter(
obj,
(struct nl_object *)neigh_handler->filter_neigh)) {
struct rtnl_neigh *neigh = (struct rtnl_neigh *)obj;
/* check that we didn't set it already */
if (neigh_handler->found_ll_addr == NULL) {
if (rtnl_neigh_get_lladdr(neigh) == NULL)
return;
neigh_handler->found_ll_addr =
nl_addr_clone(rtnl_neigh_get_lladdr(neigh));
}
}
}
static struct nl_addr *get_neigh_mac(struct get_neigh_handler *neigh_handler)
{
struct rtnl_neigh *neigh;
struct nl_addr *ll_addr = NULL;
/* future optimization - if link local address - parse address and
* return mac now instead of doing so after the routing CB. This
* is of course referred to GIDs */
neigh = rtnl_neigh_get(neigh_handler->neigh_cache,
neigh_handler->oif,
neigh_handler->dst);
if (neigh == NULL)
return NULL;
ll_addr = rtnl_neigh_get_lladdr(neigh);
if (NULL != ll_addr)
ll_addr = nl_addr_clone(ll_addr);
rtnl_neigh_put(neigh);
return ll_addr;
}
struct rtnl_nexthop *rtnl_route_nh_clone(struct rtnl_nexthop *src)
{
struct rtnl_nexthop *nh;
nh = rtnl_route_nh_alloc();
if (!nh)
return NULL;
nh->rtnh_flags = src->rtnh_flags;
nh->rtnh_flag_mask = src->rtnh_flag_mask;
nh->rtnh_weight = src->rtnh_weight;
nh->rtnh_ifindex = src->rtnh_ifindex;
nh->ce_mask = src->ce_mask;
if (src->rtnh_gateway) {
nh->rtnh_gateway = nl_addr_clone(src->rtnh_gateway);
if (!nh->rtnh_gateway) {
free(nh);
return NULL;
}
}
return nh;
}
TNlAddr::TNlAddr(const TNlAddr &other) {
if (other.Addr)
Addr = nl_addr_clone(other.Addr);
else
Addr = nullptr;
}
static int exp_clone(struct nl_object *_dst, struct nl_object *_src)
{
struct nfnl_exp *dst = (struct nfnl_exp *) _dst;
struct nfnl_exp *src = (struct nfnl_exp *) _src;
struct nl_addr *addr;
// Expectation
if (src->exp_expect.src) {
addr = nl_addr_clone(src->exp_expect.src);
if (!addr)
return -NLE_NOMEM;
dst->exp_expect.src = addr;
}
if (src->exp_expect.dst) {
addr = nl_addr_clone(src->exp_expect.dst);
if (!addr)
return -NLE_NOMEM;
dst->exp_expect.dst = addr;
}
// Master CT
if (src->exp_master.src) {
addr = nl_addr_clone(src->exp_master.src);
if (!addr)
return -NLE_NOMEM;
dst->exp_master.src = addr;
}
if (src->exp_master.dst) {
addr = nl_addr_clone(src->exp_master.dst);
if (!addr)
return -NLE_NOMEM;
dst->exp_master.dst = addr;
}
// Mask
if (src->exp_mask.src) {
addr = nl_addr_clone(src->exp_mask.src);
if (!addr)
return -NLE_NOMEM;
dst->exp_mask.src = addr;
}
if (src->exp_mask.dst) {
addr = nl_addr_clone(src->exp_mask.dst);
if (!addr)
return -NLE_NOMEM;
dst->exp_mask.dst = addr;
}
// NAT
if (src->exp_nat.src) {
addr = nl_addr_clone(src->exp_nat.src);
if (!addr)
return -NLE_NOMEM;
dst->exp_nat.src = addr;
}
if (src->exp_nat.dst) {
addr = nl_addr_clone(src->exp_nat.dst);
if (!addr)
return -NLE_NOMEM;
dst->exp_nat.dst = addr;
}
if (src->exp_fn)
dst->exp_fn = strdup(src->exp_fn);
if (src->exp_helper_name)
dst->exp_helper_name = strdup(src->exp_helper_name);
return 0;
}
