| /* 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; |
| } |
| |
| /** @} */ |