lifetime.c

/* SPDX-License-Identifier: LGPL-2.1-only */
/*
 * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
 *
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
/**
 * @ingroup xfrmnl
 * @defgroup XFRM Lifetime Configuration Object
 *
 * Abstract data type representing XFRM SA lifetime properties
 *
 * @{
 *
 * Header
 * ------
 * ~~~~{.c}
 * #include <netlink/xfrm/lifetime.h>
 * ~~~~
 */
 
#include <netlink/xfrm/lifetime.h>
#include <netlink-private/netlink.h>
 
static void ltime_cfg_destroy(struct xfrmnl_ltime_cfg* ltime)
{
        if (!ltime)
                return;
 
        if (ltime->refcnt != 1)
        {
                fprintf(stderr, "BUG: %s:%d\n", __FILE__, __LINE__);
                assert(0);
        }
 
        free(ltime);
}
 
/**
 * @name Creating Selector
 * @{
 */
 
/**
 * Allocate new lifetime config object.
 * @return Newly allocated lifetime config object or NULL
 */
struct xfrmnl_ltime_cfg* xfrmnl_ltime_cfg_alloc()
{
        struct xfrmnl_ltime_cfg* ltime;
 
        ltime = calloc(1, sizeof(struct xfrmnl_ltime_cfg));
        if (!ltime)
                return NULL;
 
        ltime->refcnt = 1;
 
        return ltime;
}
 
/**
 * Clone existing lifetime config object.
 * @arg ltime           Selector object.
 * @return Newly allocated lifetime config object being a duplicate of the
 *         specified lifetime config object or NULL if a failure occured.
 */
struct xfrmnl_ltime_cfg* xfrmnl_ltime_cfg_clone(struct xfrmnl_ltime_cfg* ltime)
{
        struct xfrmnl_ltime_cfg* new;
 
        new = xfrmnl_ltime_cfg_alloc();
        if (new)
                memcpy ((void*)new, (void*)ltime, sizeof (struct xfrmnl_ltime_cfg));
 
        return new;
}
 
/** @} */
 
/**
 * @name Managing Usage References
 * @{
 */
 
struct xfrmnl_ltime_cfg* xfrmnl_ltime_cfg_get(struct xfrmnl_ltime_cfg* ltime)
{
        ltime->refcnt++;
 
        return ltime;
}
 
void xfrmnl_ltime_cfg_put(struct xfrmnl_ltime_cfg* ltime)
{
        if (!ltime)
                return;
 
        if (ltime->refcnt == 1)
                ltime_cfg_destroy(ltime);
        else
                ltime->refcnt--;
}
 
/**
 * Check whether an lifetime config object is shared.
 * @arg addr            Selector object.
 * @return Non-zero if the lifetime config object is shared, otherwise 0.
 */
int xfrmnl_ltime_cfg_shared(struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->refcnt > 1;
}
 
/** @} */
 
/**
 * @name Miscellaneous
 * @{
 */
 
/**
 * Compares two lifetime config objects.
 * @arg a               A lifetime config object.
 * @arg b               Another lifetime config object.
 *
 * @return Non zero if difference is found, 0 otherwise if both
 * the objects are identical.
 */
int xfrmnl_ltime_cfg_cmp(struct xfrmnl_ltime_cfg* a, struct xfrmnl_ltime_cfg* b)
{
        /* Check for any differences */
        if ((a->soft_byte_limit != b->soft_byte_limit) ||
                (a->soft_packet_limit != b->soft_packet_limit) ||
                (a->hard_byte_limit != b->hard_byte_limit) ||
                (a->hard_packet_limit != b->hard_packet_limit) ||
                (a->soft_add_expires_seconds != b->soft_add_expires_seconds) ||
                (a->hard_add_expires_seconds != b->hard_add_expires_seconds) ||
                (a->soft_use_expires_seconds != b->soft_use_expires_seconds) ||
                (a->hard_use_expires_seconds != b->hard_use_expires_seconds))
                return 1;
 
        /* The objects are identical */
        return 0;
}
 
/** @} */
 
/**
 * @name Attributes
 * @{
 */
unsigned long long xfrmnl_ltime_cfg_get_soft_bytelimit (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->soft_byte_limit;
}
 
int xfrmnl_ltime_cfg_set_soft_bytelimit (struct xfrmnl_ltime_cfg* ltime, unsigned long long soft_byte_limit)
{
        ltime->soft_byte_limit = soft_byte_limit;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_hard_bytelimit (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->hard_byte_limit;
}
 
int xfrmnl_ltime_cfg_set_hard_bytelimit (struct xfrmnl_ltime_cfg* ltime, unsigned long long hard_byte_limit)
{
        ltime->hard_byte_limit = hard_byte_limit;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_soft_packetlimit (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->soft_packet_limit;
}
 
int xfrmnl_ltime_cfg_set_soft_packetlimit (struct xfrmnl_ltime_cfg* ltime, unsigned long long soft_packet_limit)
{
        ltime->soft_packet_limit = soft_packet_limit;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_hard_packetlimit (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->hard_packet_limit;
}
 
int xfrmnl_ltime_cfg_set_hard_packetlimit (struct xfrmnl_ltime_cfg* ltime, unsigned long long hard_packet_limit)
{
        ltime->hard_packet_limit = hard_packet_limit;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_soft_addexpires (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->soft_add_expires_seconds;
}
 
int xfrmnl_ltime_cfg_set_soft_addexpires (struct xfrmnl_ltime_cfg* ltime, unsigned long long soft_add_expires_seconds)
{
        ltime->soft_add_expires_seconds = soft_add_expires_seconds;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_hard_addexpires (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->hard_add_expires_seconds;
}
 
int xfrmnl_ltime_cfg_set_hard_addexpires (struct xfrmnl_ltime_cfg* ltime, unsigned long long hard_add_expires_seconds)
{
        ltime->hard_add_expires_seconds = hard_add_expires_seconds;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_soft_useexpires (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->soft_use_expires_seconds;
}
 
int xfrmnl_ltime_cfg_set_soft_useexpires (struct xfrmnl_ltime_cfg* ltime, unsigned long long soft_use_expires_seconds)
{
        ltime->soft_use_expires_seconds = soft_use_expires_seconds;
 
        return 0;
}
 
unsigned long long xfrmnl_ltime_cfg_get_hard_useexpires (struct xfrmnl_ltime_cfg* ltime)
{
        return ltime->hard_use_expires_seconds;
}
 
int xfrmnl_ltime_cfg_set_hard_useexpires (struct xfrmnl_ltime_cfg* ltime, unsigned long long hard_use_expires_seconds)
{
        ltime->hard_use_expires_seconds = hard_use_expires_seconds;
 
        return 0;
}
 
/** @} */