libsystemd-network: drop _public_ attribute

No function in libsystemd-network is exposed yet.

diff --git a/src/libsystemd-network/lldp-neighbor.c b/src/libsystemd-network/lldp-neighbor.c
index 48c2142b1e991983762bcd854333f2f6c14eb1fb..44847b2b925cdb947b5295a665ee9350d0d4a6b5 100644 (file)
--- a/src/libsystemd-network/lldp-neighbor.c
+++ b/src/libsystemd-network/lldp-neighbor.c
@@ -45,7 +45,7 @@ int lldp_neighbor_prioq_compare_func(const void *a, const void *b) {
         return CMP(x->until, y->until);
 }
 
-_public_ sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
+sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
         if (!n)
                 return NULL;
 
@@ -70,7 +70,7 @@ static sd_lldp_neighbor *lldp_neighbor_free(sd_lldp_neighbor *n) {
         return mfree(n);
 }
 
-_public_ sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
+sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
 
         /* Drops one reference from the neighbor. Note that the object is not freed unless it is already unlinked from
          * the sd_lldp object. */
@@ -358,7 +358,7 @@ bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) {
         return memcmp(LLDP_NEIGHBOR_RAW(a), LLDP_NEIGHBOR_RAW(b), a->raw_size) == 0;
 }
 
-_public_ int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct ether_addr* address) {
+int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct ether_addr* address) {
         assert_return(n, -EINVAL);
         assert_return(address, -EINVAL);
 
@@ -366,7 +366,7 @@ _public_ int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct eth
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struct ether_addr* address) {
+int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struct ether_addr* address) {
         assert_return(n, -EINVAL);
         assert_return(address, -EINVAL);
 
@@ -374,7 +374,7 @@ _public_ int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struc
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
+int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
         assert_return(size, -EINVAL);
@@ -385,7 +385,7 @@ _public_ int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, siz
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_chassis_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
+int sd_lldp_neighbor_get_chassis_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
         assert_return(n, -EINVAL);
         assert_return(type, -EINVAL);
         assert_return(ret, -EINVAL);
@@ -438,7 +438,7 @@ static int format_network_address(const void *data, size_t sz, char **ret) {
         return 1;
 }
 
-_public_ int sd_lldp_neighbor_get_chassis_id_as_string(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_chassis_id_as_string(sd_lldp_neighbor *n, const char **ret) {
         char *k;
         int r;
 
@@ -494,7 +494,7 @@ done:
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
+int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
         assert_return(n, -EINVAL);
         assert_return(type, -EINVAL);
         assert_return(ret, -EINVAL);
@@ -509,7 +509,7 @@ _public_ int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, co
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_port_id_as_string(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_port_id_as_string(sd_lldp_neighbor *n, const char **ret) {
         char *k;
         int r;
 
@@ -564,7 +564,7 @@ done:
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
+int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
         assert_return(n, -EINVAL);
         assert_return(ret_sec, -EINVAL);
 
@@ -572,7 +572,7 @@ _public_ int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -583,7 +583,7 @@ _public_ int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const char **ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -594,7 +594,7 @@ _public_ int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const char **ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -605,7 +605,7 @@ _public_ int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const ch
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_mud_url(sd_lldp_neighbor *n, const char **ret) {
+int sd_lldp_neighbor_get_mud_url(sd_lldp_neighbor *n, const char **ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -616,7 +616,7 @@ _public_ int sd_lldp_neighbor_get_mud_url(sd_lldp_neighbor *n, const char **ret)
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
+int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -627,7 +627,7 @@ _public_ int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint1
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
+int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
         assert_return(n, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -638,7 +638,7 @@ _public_ int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size) {
+int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size) {
         _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
         int r;
 
@@ -659,7 +659,7 @@ _public_ int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw,
         return r;
 }
 
-_public_ int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
+int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
         assert_return(n, -EINVAL);
 
         assert(n->raw_size >= sizeof(struct ether_header));
@@ -668,7 +668,7 @@ _public_ int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
         return n->rindex < n->raw_size;
 }
 
-_public_ int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
+int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
         size_t length;
 
         assert_return(n, -EINVAL);
@@ -687,7 +687,7 @@ _public_ int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
         return n->rindex < n->raw_size;
 }
 
-_public_ int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
+int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
         assert_return(n, -EINVAL);
         assert_return(type, -EINVAL);
 
@@ -701,7 +701,7 @@ _public_ int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
+int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
         uint8_t k;
         int r;
 
@@ -714,7 +714,7 @@ _public_ int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
         return type == k;
 }
 
-_public_ int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t *subtype) {
+int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t *subtype) {
         const uint8_t *d;
         size_t length;
         int r;
@@ -743,7 +743,7 @@ _public_ int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_A
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype) {
+int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype) {
         uint8_t k[3], st;
         int r;
 
@@ -756,7 +756,7 @@ _public_ int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[
         return memcmp(k, oui, 3) == 0 && st == subtype;
 }
 
-_public_ int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
+int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
         size_t length;
 
         assert_return(n, -EINVAL);
@@ -778,7 +778,7 @@ _public_ int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret,
         return 0;
 }
 
-_public_ int sd_lldp_neighbor_get_timestamp(sd_lldp_neighbor *n, clockid_t clock, uint64_t *ret) {
+int sd_lldp_neighbor_get_timestamp(sd_lldp_neighbor *n, clockid_t clock, uint64_t *ret) {
         assert_return(n, -EINVAL);
         assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
         assert_return(clock_supported(clock), -EOPNOTSUPP);

diff --git a/src/libsystemd-network/ndisc-router.c b/src/libsystemd-network/ndisc-router.c
index 6db07b0dbc0cca78859a0911fc63d2e50efd32ba..464b002c2f0cd686f90261ef3fb698f0229729f8 100644 (file)
--- a/src/libsystemd-network/ndisc-router.c
+++ b/src/libsystemd-network/ndisc-router.c
@@ -31,7 +31,7 @@ sd_ndisc_router *ndisc_router_new(size_t raw_size) {
         return rt;
 }
 
-_public_ int sd_ndisc_router_from_raw(sd_ndisc_router **ret, const void *raw, size_t raw_size) {
+int sd_ndisc_router_from_raw(sd_ndisc_router **ret, const void *raw, size_t raw_size) {
         _cleanup_(sd_ndisc_router_unrefp) sd_ndisc_router *rt = NULL;
         int r;
 
@@ -52,7 +52,7 @@ _public_ int sd_ndisc_router_from_raw(sd_ndisc_router **ret, const void *raw, si
         return r;
 }
 
-_public_ int sd_ndisc_router_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
+int sd_ndisc_router_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
         assert_return(rt, -EINVAL);
         assert_return(ret_addr, -EINVAL);
 
@@ -63,7 +63,7 @@ _public_ int sd_ndisc_router_get_address(sd_ndisc_router *rt, struct in6_addr *r
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_timestamp(sd_ndisc_router *rt, clockid_t clock, uint64_t *ret) {
+int sd_ndisc_router_get_timestamp(sd_ndisc_router *rt, clockid_t clock, uint64_t *ret) {
         assert_return(rt, -EINVAL);
         assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
         assert_return(clock_supported(clock), -EOPNOTSUPP);
@@ -76,7 +76,7 @@ _public_ int sd_ndisc_router_get_timestamp(sd_ndisc_router *rt, clockid_t clock,
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
+int sd_ndisc_router_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
         assert_return(rt, -EINVAL);
         assert_return(ret, -EINVAL);
         assert_return(size, -EINVAL);
@@ -231,7 +231,7 @@ int ndisc_router_parse(sd_ndisc *nd, sd_ndisc_router *rt) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_hop_limit(sd_ndisc_router *rt, uint8_t *ret) {
+int sd_ndisc_router_get_hop_limit(sd_ndisc_router *rt, uint8_t *ret) {
         assert_return(rt, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -239,7 +239,7 @@ _public_ int sd_ndisc_router_get_hop_limit(sd_ndisc_router *rt, uint8_t *ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_flags(sd_ndisc_router *rt, uint64_t *ret_flags) {
+int sd_ndisc_router_get_flags(sd_ndisc_router *rt, uint64_t *ret_flags) {
         assert_return(rt, -EINVAL);
         assert_return(ret_flags, -EINVAL);
 
@@ -247,7 +247,7 @@ _public_ int sd_ndisc_router_get_flags(sd_ndisc_router *rt, uint64_t *ret_flags)
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_lifetime(sd_ndisc_router *rt, uint16_t *ret_lifetime) {
+int sd_ndisc_router_get_lifetime(sd_ndisc_router *rt, uint16_t *ret_lifetime) {
         assert_return(rt, -EINVAL);
         assert_return(ret_lifetime, -EINVAL);
 
@@ -255,7 +255,7 @@ _public_ int sd_ndisc_router_get_lifetime(sd_ndisc_router *rt, uint16_t *ret_lif
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_preference(sd_ndisc_router *rt, unsigned *ret) {
+int sd_ndisc_router_get_preference(sd_ndisc_router *rt, unsigned *ret) {
         assert_return(rt, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -263,7 +263,7 @@ _public_ int sd_ndisc_router_get_preference(sd_ndisc_router *rt, unsigned *ret)
         return 0;
 }
 
-_public_ int sd_ndisc_router_get_mtu(sd_ndisc_router *rt, uint32_t *ret) {
+int sd_ndisc_router_get_mtu(sd_ndisc_router *rt, uint32_t *ret) {
         assert_return(rt, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -274,7 +274,7 @@ _public_ int sd_ndisc_router_get_mtu(sd_ndisc_router *rt, uint32_t *ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_option_rewind(sd_ndisc_router *rt) {
+int sd_ndisc_router_option_rewind(sd_ndisc_router *rt) {
         assert_return(rt, -EINVAL);
 
         assert(rt->raw_size >= sizeof(struct nd_router_advert));
@@ -283,7 +283,7 @@ _public_ int sd_ndisc_router_option_rewind(sd_ndisc_router *rt) {
         return rt->rindex < rt->raw_size;
 }
 
-_public_ int sd_ndisc_router_option_next(sd_ndisc_router *rt) {
+int sd_ndisc_router_option_next(sd_ndisc_router *rt) {
         size_t length;
 
         assert_return(rt, -EINVAL);
@@ -302,7 +302,7 @@ _public_ int sd_ndisc_router_option_next(sd_ndisc_router *rt) {
         return rt->rindex < rt->raw_size;
 }
 
-_public_ int sd_ndisc_router_option_get_type(sd_ndisc_router *rt, uint8_t *ret) {
+int sd_ndisc_router_option_get_type(sd_ndisc_router *rt, uint8_t *ret) {
         assert_return(rt, -EINVAL);
         assert_return(ret, -EINVAL);
 
@@ -316,7 +316,7 @@ _public_ int sd_ndisc_router_option_get_type(sd_ndisc_router *rt, uint8_t *ret)
         return 0;
 }
 
-_public_ int sd_ndisc_router_option_is_type(sd_ndisc_router *rt, uint8_t type) {
+int sd_ndisc_router_option_is_type(sd_ndisc_router *rt, uint8_t type) {
         uint8_t k;
         int r;
 
@@ -329,7 +329,7 @@ _public_ int sd_ndisc_router_option_is_type(sd_ndisc_router *rt, uint8_t type) {
         return type == k;
 }
 
-_public_ int sd_ndisc_router_option_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
+int sd_ndisc_router_option_get_raw(sd_ndisc_router *rt, const void **ret, size_t *size) {
         size_t length;
 
         assert_return(rt, -EINVAL);
@@ -377,7 +377,7 @@ static int get_prefix_info(sd_ndisc_router *rt, struct nd_opt_prefix_info **ret)
         return 0;
 }
 
-_public_ int sd_ndisc_router_prefix_get_valid_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
+int sd_ndisc_router_prefix_get_valid_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
         struct nd_opt_prefix_info *ri;
         int r;
 
@@ -392,7 +392,7 @@ _public_ int sd_ndisc_router_prefix_get_valid_lifetime(sd_ndisc_router *rt, uint
         return 0;
 }
 
-_public_ int sd_ndisc_router_prefix_get_preferred_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
+int sd_ndisc_router_prefix_get_preferred_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
         struct nd_opt_prefix_info *pi;
         int r;
 
@@ -407,7 +407,7 @@ _public_ int sd_ndisc_router_prefix_get_preferred_lifetime(sd_ndisc_router *rt,
         return 0;
 }
 
-_public_ int sd_ndisc_router_prefix_get_flags(sd_ndisc_router *rt, uint8_t *ret) {
+int sd_ndisc_router_prefix_get_flags(sd_ndisc_router *rt, uint8_t *ret) {
         struct nd_opt_prefix_info *pi;
         uint8_t flags;
         int r;
@@ -430,7 +430,7 @@ _public_ int sd_ndisc_router_prefix_get_flags(sd_ndisc_router *rt, uint8_t *ret)
         return 0;
 }
 
-_public_ int sd_ndisc_router_prefix_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
+int sd_ndisc_router_prefix_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
         struct nd_opt_prefix_info *pi;
         int r;
 
@@ -445,7 +445,7 @@ _public_ int sd_ndisc_router_prefix_get_address(sd_ndisc_router *rt, struct in6_
         return 0;
 }
 
-_public_ int sd_ndisc_router_prefix_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
+int sd_ndisc_router_prefix_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
         struct nd_opt_prefix_info *pi;
         int r;
 
@@ -490,7 +490,7 @@ static int get_route_info(sd_ndisc_router *rt, uint8_t **ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_route_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
+int sd_ndisc_router_route_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
         uint8_t *ri;
         int r;
 
@@ -505,7 +505,7 @@ _public_ int sd_ndisc_router_route_get_lifetime(sd_ndisc_router *rt, uint32_t *r
         return 0;
 }
 
-_public_ int sd_ndisc_router_route_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
+int sd_ndisc_router_route_get_address(sd_ndisc_router *rt, struct in6_addr *ret_addr) {
         uint8_t *ri;
         int r;
 
@@ -522,7 +522,7 @@ _public_ int sd_ndisc_router_route_get_address(sd_ndisc_router *rt, struct in6_a
         return 0;
 }
 
-_public_ int sd_ndisc_router_route_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
+int sd_ndisc_router_route_get_prefixlen(sd_ndisc_router *rt, unsigned *ret) {
         uint8_t *ri;
         int r;
 
@@ -537,7 +537,7 @@ _public_ int sd_ndisc_router_route_get_prefixlen(sd_ndisc_router *rt, unsigned *
         return 0;
 }
 
-_public_ int sd_ndisc_router_route_get_preference(sd_ndisc_router *rt, unsigned *ret) {
+int sd_ndisc_router_route_get_preference(sd_ndisc_router *rt, unsigned *ret) {
         uint8_t *ri;
         int r;
 
@@ -576,7 +576,7 @@ static int get_rdnss_info(sd_ndisc_router *rt, uint8_t **ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_rdnss_get_addresses(sd_ndisc_router *rt, const struct in6_addr **ret) {
+int sd_ndisc_router_rdnss_get_addresses(sd_ndisc_router *rt, const struct in6_addr **ret) {
         uint8_t *ri;
         int r;
 
@@ -591,7 +591,7 @@ _public_ int sd_ndisc_router_rdnss_get_addresses(sd_ndisc_router *rt, const stru
         return (NDISC_ROUTER_OPTION_LENGTH(rt) - 8) / 16;
 }
 
-_public_ int sd_ndisc_router_rdnss_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
+int sd_ndisc_router_rdnss_get_lifetime(sd_ndisc_router *rt, uint32_t *ret) {
         uint8_t *ri;
         int r;
 
@@ -627,7 +627,7 @@ static int get_dnssl_info(sd_ndisc_router *rt, uint8_t **ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_router_dnssl_get_domains(sd_ndisc_router *rt, char ***ret) {
+int sd_ndisc_router_dnssl_get_domains(sd_ndisc_router *rt, char ***ret) {
         _cleanup_strv_free_ char **l = NULL;
         _cleanup_free_ char *e = NULL;
         size_t n = 0, left;
@@ -719,7 +719,7 @@ _public_ int sd_ndisc_router_dnssl_get_domains(sd_ndisc_router *rt, char ***ret)
         return k;
 }
 
-_public_ int sd_ndisc_router_dnssl_get_lifetime(sd_ndisc_router *rt, uint32_t *ret_sec) {
+int sd_ndisc_router_dnssl_get_lifetime(sd_ndisc_router *rt, uint32_t *ret_sec) {
         uint8_t *ri;
         int r;
 

diff --git a/src/libsystemd-network/sd-lldp-rx.c b/src/libsystemd-network/sd-lldp-rx.c
index 7224d3a345db6ec1e5fe3d1c0b50a143eb086c95..761e4b31282a2d4553e909700ad81deabed6fbd8 100644 (file)
--- a/src/libsystemd-network/sd-lldp-rx.c
+++ b/src/libsystemd-network/sd-lldp-rx.c
@@ -249,7 +249,7 @@ int sd_lldp_rx_is_running(sd_lldp_rx *lldp_rx) {
         return lldp_rx->fd >= 0;
 }
 
-_public_ int sd_lldp_rx_start(sd_lldp_rx *lldp_rx) {
+int sd_lldp_rx_start(sd_lldp_rx *lldp_rx) {
         int r;
 
         assert_return(lldp_rx, -EINVAL);
@@ -283,7 +283,7 @@ fail:
         return r;
 }
 
-_public_ int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) {
+int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) {
         if (!sd_lldp_rx_is_running(lldp_rx))
                 return 0;
 
@@ -295,7 +295,7 @@ _public_ int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) {
         return 1;
 }
 
-_public_ int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority) {
+int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority) {
         int r;
 
         assert_return(lldp_rx, -EINVAL);
@@ -315,7 +315,7 @@ _public_ int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64
         return 0;
 }
 
-_public_ int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx) {
+int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx) {
         assert_return(lldp_rx, -EINVAL);
         assert_return(!sd_lldp_rx_is_running(lldp_rx), -EBUSY);
 
@@ -325,13 +325,13 @@ _public_ int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx) {
         return 0;
 }
 
-_public_ sd_event* sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx) {
+sd_event* sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx) {
         assert_return(lldp_rx, NULL);
 
         return lldp_rx->event;
 }
 
-_public_ int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata) {
+int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata) {
         assert_return(lldp_rx, -EINVAL);
 
         lldp_rx->callback = cb;
@@ -340,7 +340,7 @@ _public_ int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t
         return 0;
 }
 
-_public_ int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex) {
+int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex) {
         assert_return(lldp_rx, -EINVAL);
         assert_return(ifindex > 0, -EINVAL);
         assert_return(!sd_lldp_rx_is_running(lldp_rx), -EBUSY);
@@ -392,7 +392,7 @@ static sd_lldp_rx *lldp_rx_free(sd_lldp_rx *lldp_rx) {
 
 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp_rx, sd_lldp_rx, lldp_rx_free);
 
-_public_ int sd_lldp_rx_new(sd_lldp_rx **ret) {
+int sd_lldp_rx_new(sd_lldp_rx **ret) {
         _cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
 
         assert_return(ret, -EINVAL);
@@ -460,7 +460,7 @@ static inline int neighbor_compare_func(sd_lldp_neighbor * const *a, sd_lldp_nei
         return lldp_neighbor_id_compare_func(&(*a)->id, &(*b)->id);
 }
 
-_public_ int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***ret) {
+int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***ret) {
         _cleanup_free_ sd_lldp_neighbor **l = NULL;
         sd_lldp_neighbor *n;
         int k = 0;
@@ -489,7 +489,7 @@ _public_ int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***r
         return k;
 }
 
-_public_ int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) {
+int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) {
         assert_return(lldp_rx, -EINVAL);
         assert_return(m > 0, -EINVAL);
 
@@ -499,7 +499,7 @@ _public_ int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) {
         return 0;
 }
 
-_public_ int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) {
+int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) {
         assert_return(lldp_rx, -EINVAL);
         assert_return(mask != 0, -EINVAL);
 
@@ -508,7 +508,7 @@ _public_ int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) {
         return 0;
 }
 
-_public_ int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *addr) {
+int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *addr) {
         assert_return(lldp_rx, -EINVAL);
 
         /* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so

diff --git a/src/libsystemd-network/sd-ndisc.c b/src/libsystemd-network/sd-ndisc.c
index 276c205ecfb60e38b6a242eee5a9ea7253adfcf6..424526db9870e28a4bb8e6d6ba7f036c7be88917 100644 (file)
--- a/src/libsystemd-network/sd-ndisc.c
+++ b/src/libsystemd-network/sd-ndisc.c
@@ -42,7 +42,7 @@ static void ndisc_callback(sd_ndisc *ndisc, sd_ndisc_event_t event, sd_ndisc_rou
         ndisc->callback(ndisc, event, rt, ndisc->userdata);
 }
 
-_public_ int sd_ndisc_set_callback(
+int sd_ndisc_set_callback(
                 sd_ndisc *nd,
                 sd_ndisc_callback_t callback,
                 void *userdata) {
@@ -55,7 +55,7 @@ _public_ int sd_ndisc_set_callback(
         return 0;
 }
 
-_public_ int sd_ndisc_set_ifindex(sd_ndisc *nd, int ifindex) {
+int sd_ndisc_set_ifindex(sd_ndisc *nd, int ifindex) {
         assert_return(nd, -EINVAL);
         assert_return(ifindex > 0, -EINVAL);
         assert_return(nd->fd < 0, -EBUSY);
@@ -89,7 +89,7 @@ int sd_ndisc_get_ifname(sd_ndisc *nd, const char **ret) {
         return 0;
 }
 
-_public_ int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
+int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
         assert_return(nd, -EINVAL);
 
         if (mac_addr)
@@ -100,7 +100,7 @@ _public_ int sd_ndisc_set_mac(sd_ndisc *nd, const struct ether_addr *mac_addr) {
         return 0;
 }
 
-_public_ int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priority) {
+int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priority) {
         int r;
 
         assert_return(nd, -EINVAL);
@@ -120,7 +120,7 @@ _public_ int sd_ndisc_attach_event(sd_ndisc *nd, sd_event *event, int64_t priori
         return 0;
 }
 
-_public_ int sd_ndisc_detach_event(sd_ndisc *nd) {
+int sd_ndisc_detach_event(sd_ndisc *nd) {
 
         assert_return(nd, -EINVAL);
         assert_return(nd->fd < 0, -EBUSY);
@@ -129,7 +129,7 @@ _public_ int sd_ndisc_detach_event(sd_ndisc *nd) {
         return 0;
 }
 
-_public_ sd_event *sd_ndisc_get_event(sd_ndisc *nd) {
+sd_event *sd_ndisc_get_event(sd_ndisc *nd) {
         assert_return(nd, NULL);
 
         return nd->event;
@@ -160,7 +160,7 @@ static sd_ndisc *ndisc_free(sd_ndisc *nd) {
 
 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_ndisc, sd_ndisc, ndisc_free);
 
-_public_ int sd_ndisc_new(sd_ndisc **ret) {
+int sd_ndisc_new(sd_ndisc **ret) {
         _cleanup_(sd_ndisc_unrefp) sd_ndisc *nd = NULL;
 
         assert_return(ret, -EINVAL);
@@ -317,7 +317,7 @@ static int ndisc_timeout_no_ra(sd_event_source *s, uint64_t usec, void *userdata
         return 0;
 }
 
-_public_ int sd_ndisc_stop(sd_ndisc *nd) {
+int sd_ndisc_stop(sd_ndisc *nd) {
         if (!nd)
                 return 0;
 
@@ -330,7 +330,7 @@ _public_ int sd_ndisc_stop(sd_ndisc *nd) {
         return 1;
 }
 
-_public_ int sd_ndisc_start(sd_ndisc *nd) {
+int sd_ndisc_start(sd_ndisc *nd) {
         int r;
         usec_t time_now;
 

diff --git a/src/libsystemd-network/sd-radv.c b/src/libsystemd-network/sd-radv.c
index f5432b503532e55f5077f2100a0053166c9da2fe..4f5dbf0090b9f4a090950dcefa9d499e81202c85 100644 (file)
--- a/src/libsystemd-network/sd-radv.c
+++ b/src/libsystemd-network/sd-radv.c
@@ -26,7 +26,7 @@
 #include "string-util.h"
 #include "strv.h"
 
-_public_ int sd_radv_new(sd_radv **ret) {
+int sd_radv_new(sd_radv **ret) {
         _cleanup_(sd_radv_unrefp) sd_radv *ra = NULL;
 
         assert_return(ret, -EINVAL);
@@ -46,7 +46,7 @@ _public_ int sd_radv_new(sd_radv **ret) {
         return 0;
 }
 
-_public_ int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority) {
+int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority) {
         int r;
 
         assert_return(ra, -EINVAL);
@@ -65,7 +65,7 @@ _public_ int sd_radv_attach_event(sd_radv *ra, sd_event *event, int64_t priority
         return 0;
 }
 
-_public_ int sd_radv_detach_event(sd_radv *ra) {
+int sd_radv_detach_event(sd_radv *ra) {
 
         assert_return(ra, -EINVAL);
 
@@ -73,13 +73,13 @@ _public_ int sd_radv_detach_event(sd_radv *ra) {
         return 0;
 }
 
-_public_ sd_event *sd_radv_get_event(sd_radv *ra) {
+sd_event *sd_radv_get_event(sd_radv *ra) {
         assert_return(ra, NULL);
 
         return ra->event;
 }
 
-_public_ int sd_radv_is_running(sd_radv *ra) {
+int sd_radv_is_running(sd_radv *ra) {
         assert_return(ra, false);
 
         return ra->state != RADV_STATE_IDLE;
@@ -371,7 +371,7 @@ fail:
         return 0;
 }
 
-_public_ int sd_radv_stop(sd_radv *ra) {
+int sd_radv_stop(sd_radv *ra) {
         int r;
 
         if (!ra)
@@ -395,7 +395,7 @@ _public_ int sd_radv_stop(sd_radv *ra) {
         return 0;
 }
 
-_public_ int sd_radv_start(sd_radv *ra) {
+int sd_radv_start(sd_radv *ra) {
         int r;
 
         assert_return(ra, -EINVAL);
@@ -441,7 +441,7 @@ _public_ int sd_radv_start(sd_radv *ra) {
         return r;
 }
 
-_public_ int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
+int sd_radv_set_ifindex(sd_radv *ra, int ifindex) {
         assert_return(ra, -EINVAL);
         assert_return(ifindex > 0, -EINVAL);
 
@@ -478,7 +478,7 @@ int sd_radv_get_ifname(sd_radv *ra, const char **ret) {
         return 0;
 }
 
-_public_ int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
+int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
         assert_return(ra, -EINVAL);
 
         if (ra->state != RADV_STATE_IDLE)
@@ -492,7 +492,7 @@ _public_ int sd_radv_set_mac(sd_radv *ra, const struct ether_addr *mac_addr) {
         return 0;
 }
 
-_public_ int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
+int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
         assert_return(ra, -EINVAL);
         assert_return(mtu >= 1280, -EINVAL);
 
@@ -501,7 +501,7 @@ _public_ int sd_radv_set_mtu(sd_radv *ra, uint32_t mtu) {
         return 0;
 }
 
-_public_ int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
+int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
         assert_return(ra, -EINVAL);
 
         if (ra->state != RADV_STATE_IDLE)
@@ -512,7 +512,7 @@ _public_ int sd_radv_set_hop_limit(sd_radv *ra, uint8_t hop_limit) {
         return 0;
 }
 
-_public_ int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t lifetime_usec) {
+int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t lifetime_usec) {
         assert_return(ra, -EINVAL);
 
         if (ra->state != RADV_STATE_IDLE)
@@ -532,7 +532,7 @@ _public_ int sd_radv_set_router_lifetime(sd_radv *ra, uint64_t lifetime_usec) {
         return 0;
 }
 
-_public_ int sd_radv_set_managed_information(sd_radv *ra, int managed) {
+int sd_radv_set_managed_information(sd_radv *ra, int managed) {
         assert_return(ra, -EINVAL);
 
         if (ra->state != RADV_STATE_IDLE)
@@ -543,7 +543,7 @@ _public_ int sd_radv_set_managed_information(sd_radv *ra, int managed) {
         return 0;
 }
 
-_public_ int sd_radv_set_other_information(sd_radv *ra, int other) {
+int sd_radv_set_other_information(sd_radv *ra, int other) {
         assert_return(ra, -EINVAL);
 
         if (ra->state != RADV_STATE_IDLE)
@@ -554,7 +554,7 @@ _public_ int sd_radv_set_other_information(sd_radv *ra, int other) {
         return 0;
 }
 
-_public_ int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
+int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
         assert_return(ra, -EINVAL);
         assert_return(IN_SET(preference,
                              SD_NDISC_PREFERENCE_LOW,
@@ -571,7 +571,7 @@ _public_ int sd_radv_set_preference(sd_radv *ra, unsigned preference) {
         return 0;
 }
 
-_public_ int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p) {
+int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p) {
         _cleanup_free_ char *addr_p = NULL;
         sd_radv_prefix *cur;
         int r;
@@ -643,7 +643,7 @@ _public_ int sd_radv_add_prefix(sd_radv *ra, sd_radv_prefix *p) {
         return 0;
 }
 
-_public_ sd_radv_prefix *sd_radv_remove_prefix(sd_radv *ra,
+sd_radv_prefix *sd_radv_remove_prefix(sd_radv *ra,
                                                const struct in6_addr *prefix,
                                                unsigned char prefixlen) {
         sd_radv_prefix *cur, *next;
@@ -668,7 +668,7 @@ _public_ sd_radv_prefix *sd_radv_remove_prefix(sd_radv *ra,
         return cur;
 }
 
-_public_ int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p) {
+int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p) {
         _cleanup_free_ char *addr_p = NULL;
         sd_radv_route_prefix *cur;
         int r;
@@ -735,7 +735,7 @@ _public_ int sd_radv_add_route_prefix(sd_radv *ra, sd_radv_route_prefix *p) {
         return 0;
 }
 
-_public_ int sd_radv_set_rdnss(sd_radv *ra, uint32_t lifetime,
+int sd_radv_set_rdnss(sd_radv *ra, uint32_t lifetime,
                                const struct in6_addr *dns, size_t n_dns) {
         _cleanup_free_ struct sd_radv_opt_dns *opt_rdnss = NULL;
         size_t len;
@@ -769,7 +769,7 @@ _public_ int sd_radv_set_rdnss(sd_radv *ra, uint32_t lifetime,
         return 0;
 }
 
-_public_ int sd_radv_set_dnssl(sd_radv *ra, uint32_t lifetime,
+int sd_radv_set_dnssl(sd_radv *ra, uint32_t lifetime,
                                char **search_list) {
         _cleanup_free_ struct sd_radv_opt_dns *opt_dnssl = NULL;
         size_t len = 0;
@@ -818,7 +818,7 @@ _public_ int sd_radv_set_dnssl(sd_radv *ra, uint32_t lifetime,
         return 0;
 }
 
-_public_ int sd_radv_prefix_new(sd_radv_prefix **ret) {
+int sd_radv_prefix_new(sd_radv_prefix **ret) {
         sd_radv_prefix *p;
 
         assert_return(ret, -EINVAL);
@@ -849,7 +849,7 @@ _public_ int sd_radv_prefix_new(sd_radv_prefix **ret) {
 
 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_prefix, sd_radv_prefix, mfree);
 
-_public_ int sd_radv_prefix_set_prefix(sd_radv_prefix *p, const struct in6_addr *in6_addr,
+int sd_radv_prefix_set_prefix(sd_radv_prefix *p, const struct in6_addr *in6_addr,
                                        unsigned char prefixlen) {
         assert_return(p, -EINVAL);
         assert_return(in6_addr, -EINVAL);
@@ -867,7 +867,7 @@ _public_ int sd_radv_prefix_set_prefix(sd_radv_prefix *p, const struct in6_addr
         return 0;
 }
 
-_public_ int sd_radv_prefix_get_prefix(sd_radv_prefix *p, struct in6_addr *ret_in6_addr,
+int sd_radv_prefix_get_prefix(sd_radv_prefix *p, struct in6_addr *ret_in6_addr,
                                        unsigned char *ret_prefixlen) {
         assert_return(p, -EINVAL);
         assert_return(ret_in6_addr, -EINVAL);
@@ -879,7 +879,7 @@ _public_ int sd_radv_prefix_get_prefix(sd_radv_prefix *p, struct in6_addr *ret_i
         return 0;
 }
 
-_public_ int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
+int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
         assert_return(p, -EINVAL);
 
         SET_FLAG(p->opt.flags, ND_OPT_PI_FLAG_ONLINK, onlink);
@@ -887,7 +887,7 @@ _public_ int sd_radv_prefix_set_onlink(sd_radv_prefix *p, int onlink) {
         return 0;
 }
 
-_public_ int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p,
+int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p,
                                                           int address_autoconfiguration) {
         assert_return(p, -EINVAL);
 
@@ -896,7 +896,7 @@ _public_ int sd_radv_prefix_set_address_autoconfiguration(sd_radv_prefix *p,
         return 0;
 }
 
-_public_ int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
+int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
         assert_return(p, -EINVAL);
 
         p->lifetime_valid_usec = lifetime_usec;
@@ -905,7 +905,7 @@ _public_ int sd_radv_prefix_set_valid_lifetime(sd_radv_prefix *p, uint64_t lifet
         return 0;
 }
 
-_public_ int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
+int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
         assert_return(p, -EINVAL);
 
         p->lifetime_preferred_usec = lifetime_usec;
@@ -914,7 +914,7 @@ _public_ int sd_radv_prefix_set_preferred_lifetime(sd_radv_prefix *p, uint64_t l
         return 0;
 }
 
-_public_ int sd_radv_route_prefix_new(sd_radv_route_prefix **ret) {
+int sd_radv_route_prefix_new(sd_radv_route_prefix **ret) {
         sd_radv_route_prefix *p;
 
         assert_return(ret, -EINVAL);
@@ -940,7 +940,7 @@ _public_ int sd_radv_route_prefix_new(sd_radv_route_prefix **ret) {
 
 DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_radv_route_prefix, sd_radv_route_prefix, mfree);
 
-_public_ int sd_radv_route_prefix_set_prefix(sd_radv_route_prefix *p, const struct in6_addr *in6_addr,
+int sd_radv_route_prefix_set_prefix(sd_radv_route_prefix *p, const struct in6_addr *in6_addr,
                                              unsigned char prefixlen) {
         assert_return(p, -EINVAL);
         assert_return(in6_addr, -EINVAL);
@@ -958,7 +958,7 @@ _public_ int sd_radv_route_prefix_set_prefix(sd_radv_route_prefix *p, const stru
         return 0;
 }
 
-_public_ int sd_radv_route_prefix_set_lifetime(sd_radv_route_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
+int sd_radv_route_prefix_set_lifetime(sd_radv_route_prefix *p, uint64_t lifetime_usec, uint64_t valid_until) {
         assert_return(p, -EINVAL);
 
         p->lifetime_usec = lifetime_usec;