linked-list: Change return value of find_first() and signature of its callback
authorTobias Brunner <tobias@strongswan.org>
Tue, 16 May 2017 10:11:24 +0000 (12:11 +0200)
committerTobias Brunner <tobias@strongswan.org>
Fri, 26 May 2017 11:56:44 +0000 (13:56 +0200)
This avoids the unportable five pointer hack.

29 files changed:
src/charon-tkm/src/tkm/tkm_kernel_sad.c
src/dumm/cowfs.c
src/frontends/android/app/src/main/jni/libandroidbridge/kernel/android_net.c
src/libcharon/bus/bus.c
src/libcharon/config/child_cfg.c
src/libcharon/daemon.c
src/libcharon/kernel/kernel_interface.c
src/libcharon/plugins/bypass_lan/bypass_lan_listener.c
src/libcharon/plugins/dhcp/dhcp_provider.c
src/libcharon/plugins/dhcp/dhcp_socket.c
src/libcharon/plugins/eap_dynamic/eap_dynamic.c
src/libcharon/plugins/kernel_libipsec/kernel_libipsec_ipsec.c
src/libcharon/plugins/kernel_netlink/kernel_netlink_net.c
src/libcharon/plugins/kernel_pfkey/kernel_pfkey_ipsec.c
src/libcharon/plugins/p_cscf/p_cscf_handler.c
src/libcharon/plugins/stroke/stroke_ca.c
src/libcharon/plugins/stroke/stroke_list.c
src/libcharon/sa/ike_sa_manager.c
src/libcharon/sa/ikev2/connect_manager.c
src/libcharon/sa/ikev2/tasks/child_delete.c
src/libcharon/sa/trap_manager.c
src/libipsec/ipsec_sa_mgr.c
src/libstrongswan/collections/linked_list.c
src/libstrongswan/collections/linked_list.h
src/libstrongswan/credentials/credential_manager.c
src/libstrongswan/credentials/sets/mem_cred.c
src/libstrongswan/crypto/crypto_factory.c
src/libstrongswan/plugins/plugin_loader.c
src/libstrongswan/tests/suites/test_linked_list.c

index 22d2aac..97226f1 100644 (file)
@@ -101,61 +101,63 @@ static void sad_entry_destroy(sad_entry_t *entry)
        }
 }
 
-/**
- * Find a list entry with given src, dst, (remote) spi and proto values.
- */
-static bool sad_entry_match(sad_entry_t * const entry, const host_t * const src,
-                                                       const host_t * const dst, const uint32_t * const spi,
-                                                       const uint8_t * const proto)
+CALLBACK(sad_entry_match, bool,
+       sad_entry_t * const entry, va_list args)
 {
+       const host_t *src, *dst;
+       const uint32_t *spi;
+       const uint8_t *proto;
+
+       VA_ARGS_VGET(args, src, dst, spi, proto);
+
        if (entry->src == NULL || entry->dst == NULL)
        {
                return FALSE;
        }
-
        return src->ip_equals(entry->src, (host_t *)src) &&
                   dst->ip_equals(entry->dst, (host_t *)dst) &&
                   entry->spi_rem == *spi && entry->proto == *proto;
 }
 
-/**
- * Find a list entry with given reqid, spi and proto values.
- */
-static bool sad_entry_match_dst(sad_entry_t * const entry,
-                                                               const uint32_t * const reqid,
-                                                               const uint32_t * const spi,
-                                                               const uint8_t * const proto)
+CALLBACK(sad_entry_match_dst, bool,
+       sad_entry_t * const entry, va_list args)
 {
+       const uint32_t *reqid, *spi;
+       const uint8_t *proto;
+
+       VA_ARGS_VGET(args, reqid, spi, proto);
        return entry->reqid   == *reqid &&
                   entry->spi_rem == *spi   &&
                   entry->proto   == *proto;
 }
 
-/**
- * Find a list entry with given esa id.
- */
-static bool sad_entry_match_esa_id(sad_entry_t * const entry,
-                                                                  const esa_id_type * const esa_id)
+CALLBACK(sad_entry_match_esa_id, bool,
+       sad_entry_t * const entry, va_list args)
 {
+       const esa_id_type *esa_id;
+
+       VA_ARGS_VGET(args, esa_id);
        return entry->esa_id == *esa_id;
 }
 
-/**
- * Find a list entry with given reqid and different esa id.
- */
-static bool sad_entry_match_other_esa(sad_entry_t * const entry,
-                                                                         const esa_id_type * const esa_id,
-                                                                         const uint32_t * const reqid)
+CALLBACK(sad_entry_match_other_esa, bool,
+       sad_entry_t * const entry, va_list args)
 {
+       const esa_id_type *esa_id;
+       const uint32_t *reqid;
+
+       VA_ARGS_VGET(args, esa_id, reqid);
        return entry->reqid  == *reqid &&
                   entry->esa_id != *esa_id;
 }
 
-/**
- * Compare two SAD entries for equality.
- */
-static bool sad_entry_equal(sad_entry_t * const left, sad_entry_t * const right)
+CALLBACK(sad_entry_equal, bool,
+       sad_entry_t * const left, va_list args)
 {
+       sad_entry_t *right;
+
+       VA_ARGS_VGET(args, right);
+
        if (left->src == NULL || left->dst == NULL || right->src == NULL ||
                right->dst == NULL)
        {
@@ -175,8 +177,8 @@ METHOD(tkm_kernel_sad_t, insert, bool,
        const uint32_t reqid, const host_t * const src, const host_t * const dst,
        const uint32_t spi_loc, const uint32_t spi_rem, const uint8_t proto)
 {
-       status_t result;
        sad_entry_t *new_entry;
+       bool found;
 
        INIT(new_entry,
                 .esa_id = esa_id,
@@ -189,10 +191,9 @@ METHOD(tkm_kernel_sad_t, insert, bool,
        );
 
        this->mutex->lock(this->mutex);
-       result = this->data->find_first(this->data,
-                                                                       (linked_list_match_t)sad_entry_equal, NULL,
+       found = this->data->find_first(this->data, sad_entry_equal, NULL,
                                                                        new_entry);
-       if (result == NOT_FOUND)
+       if (!found)
        {
                DBG3(DBG_KNL, "inserting SAD entry (esa: %llu, reqid: %u, src: %H, "
                         "dst: %H, spi_loc: %x, spi_rem: %x,proto: %u)", esa_id, reqid, src,
@@ -207,7 +208,7 @@ METHOD(tkm_kernel_sad_t, insert, bool,
                free(new_entry);
        }
        this->mutex->unlock(this->mutex);
-       return result == NOT_FOUND;
+       return !found;
 }
 
 METHOD(tkm_kernel_sad_t, get_esa_id, esa_id_type,
@@ -218,11 +219,10 @@ METHOD(tkm_kernel_sad_t, get_esa_id, esa_id_type,
        sad_entry_t *entry = NULL;
 
        this->mutex->lock(this->mutex);
-       const status_t res = this->data->find_first(this->data,
-                                                                                               (linked_list_match_t)sad_entry_match,
-                                                                                               (void**)&entry, src, dst, &spi,
-                                                                                               &proto);
-       if (res == SUCCESS && entry)
+       const bool res = this->data->find_first(this->data, sad_entry_match,
+                                                                                       (void**)&entry, src, dst, &spi,
+                                                                                       &proto);
+       if (res && entry)
        {
                id = entry->esa_id;
                DBG3(DBG_KNL, "returning ESA id %llu of SAD entry (src: %H, dst: %H, "
@@ -243,13 +243,12 @@ METHOD(tkm_kernel_sad_t, get_other_esa_id, esa_id_type,
        esa_id_type id = 0;
        sad_entry_t *entry = NULL;
        uint32_t reqid;
-       status_t res;
+       bool res;
 
        this->mutex->lock(this->mutex);
-       res = this->data->find_first(this->data,
-                                                                (linked_list_match_t)sad_entry_match_esa_id,
+       res = this->data->find_first(this->data, sad_entry_match_esa_id,
                                                                 (void**)&entry, &esa_id);
-       if (res == SUCCESS && entry)
+       if (res && entry)
        {
                reqid = entry->reqid;
        }
@@ -260,10 +259,9 @@ METHOD(tkm_kernel_sad_t, get_other_esa_id, esa_id_type,
                return id;
        }
 
-       res = this->data->find_first(this->data,
-                                                                (linked_list_match_t)sad_entry_match_other_esa,
+       res = this->data->find_first(this->data, sad_entry_match_other_esa,
                                                                 (void**)&entry, &esa_id, &reqid);
-       if (res == SUCCESS && entry)
+       if (res && entry)
        {
                id = entry->esa_id;
                DBG3(DBG_KNL, "returning ESA id %llu of other SAD entry with reqid %u",
@@ -281,10 +279,9 @@ METHOD(tkm_kernel_sad_t, get_dst_host, host_t *,
        sad_entry_t *entry = NULL;
 
        this->mutex->lock(this->mutex);
-       const status_t res = this->data->find_first(this->data,
-                                                                                               (linked_list_match_t)sad_entry_match_dst,
-                                                                                               (void**)&entry, &reqid, &spi, &proto);
-       if (res == SUCCESS && entry)
+       const bool res = this->data->find_first(this->data, sad_entry_match_dst,
+                                                                                       (void**)&entry, &reqid, &spi, &proto);
+       if (res && entry)
        {
                dst = entry->dst;
                DBG3(DBG_KNL, "returning destination host %H of SAD entry (reqid: %u,"
index 28c62c2..5332ba5 100644 (file)
@@ -92,11 +92,12 @@ static void overlay_destroy(overlay_t *this)
        free(this);
 }
 
-/**
- * compare two overlays by path
- */
-static bool overlay_equals(overlay_t *this, overlay_t *other)
+CALLBACK(overlay_equals, bool,
+       overlay_t *this, va_list args)
 {
+       overlay_t *other;
+
+       VA_ARGS_VGET(args, other);
        return streq(this->path, other->path);
 }
 
@@ -108,8 +109,8 @@ static bool overlay_remove(private_cowfs_t *this, char *path)
 {
        overlay_t over, *current;
        over.path = path;
-       if (this->overlays->find_first(this->overlays,
-                       (linked_list_match_t)overlay_equals, (void**)&current, &over) != SUCCESS)
+       if (!this->overlays->find_first(this->overlays, overlay_equals,
+                                                                       (void**)&current, &over))
        {
                return FALSE;
        }
index a73a3c0..c6ef06a 100644 (file)
@@ -167,6 +167,15 @@ METHOD(kernel_net_t, get_source_addr, host_t*,
        return host_create_from_sockaddr((sockaddr_t*)&addr);
 }
 
+CALLBACK(vip_equals, bool,
+       host_t *vip, va_list args)
+{
+       host_t *host;
+
+       VA_ARGS_VGET(args, host);
+       return host->ip_equals(host, vip);
+}
+
 METHOD(kernel_net_t, get_source_addr_old, host_t*,
        private_android_net_t *this, host_t *dest, host_t *src)
 {
@@ -179,8 +188,7 @@ METHOD(kernel_net_t, get_source_addr_old, host_t*,
        if (host)
        {
                this->mutex->lock(this->mutex);
-               if (this->vips->find_first(this->vips, (void*)host->ip_equals,
-                                                                  NULL, host) == SUCCESS)
+               if (this->vips->find_first(this->vips, vip_equals, NULL, host))
                {
                        host->destroy(host);
                        host = NULL;
@@ -236,8 +244,8 @@ METHOD(kernel_net_t, del_ip, status_t,
        host_t *vip;
 
        this->mutex->lock(this->mutex);
-       if (this->vips->find_first(this->vips, (void*)virtual_ip->ip_equals,
-                                                          (void**)&vip, virtual_ip) == SUCCESS)
+       if (this->vips->find_first(this->vips, vip_equals, (void**)&vip,
+                                                          virtual_ip))
        {
                this->vips->remove(this->vips, vip, NULL);
                vip->destroy(vip);
index 4ee89db..77a9101 100644 (file)
@@ -207,20 +207,20 @@ static inline void register_logger(private_bus_t *this, debug_t group,
        }
 }
 
-/**
- * Find the log level of the first registered logger that implements log or
- * vlog (or both).
- */
-static bool find_max_levels(log_entry_t *entry, debug_t *group, level_t *level,
-                                                       level_t *vlevel)
+CALLBACK(find_max_levels, bool,
+       log_entry_t *entry, va_list args)
 {
+       level_t *level, *vlevel;
+       debug_t group;
+
+       VA_ARGS_VGET(args, group, level, vlevel);
        if (entry->logger->log && *level == LEVEL_SILENT)
        {
-               *level = entry->levels[*group];
+               *level = entry->levels[group];
        }
        if (entry->logger->vlog && *vlevel == LEVEL_SILENT)
        {
-               *vlevel = entry->levels[*group];
+               *vlevel = entry->levels[group];
        }
        return *level > LEVEL_SILENT && *vlevel > LEVEL_SILENT;
 }
@@ -258,8 +258,8 @@ static inline void unregister_logger(private_bus_t *this, logger_t *logger)
 
                                loggers = this->loggers[group];
                                loggers->remove(loggers, found, NULL);
-                               loggers->find_first(loggers, (linked_list_match_t)find_max_levels,
-                                                                       NULL, &group, &level, &vlevel);
+                               loggers->find_first(loggers, find_max_levels, NULL, group,
+                                                                       &level, &vlevel);
                                set_level(&this->max_level[group], level);
                                set_level(&this->max_vlevel[group], vlevel);
                        }
index 669eedf..ec2a124 100644 (file)
@@ -165,8 +165,12 @@ METHOD(child_cfg_t, add_proposal, void,
        }
 }
 
-static bool match_proposal(proposal_t *item, proposal_t *proposal)
+CALLBACK(match_proposal, bool,
+       proposal_t *item, va_list args)
 {
+       proposal_t *proposal;
+
+       VA_ARGS_VGET(args, proposal);
        return item->equals(item, proposal);
 }
 
@@ -185,8 +189,7 @@ METHOD(child_cfg_t, get_proposals, linked_list_t*,
                {
                        current->strip_dh(current, MODP_NONE);
                }
-               if (proposals->find_first(proposals, (linked_list_match_t)match_proposal,
-                                                                 NULL, current) == SUCCESS)
+               if (proposals->find_first(proposals, match_proposal, NULL, current))
                {
                        current->destroy(current);
                        continue;
index 8daea78..7c9f83d 100644 (file)
@@ -282,13 +282,14 @@ static void logger_entry_unregister_destroy(logger_entry_t *this)
        logger_entry_destroy(this);
 }
 
-/**
- * Match a logger entry by target and whether it is a file or syslog logger
- */
-static bool logger_entry_match(logger_entry_t *this, char *target,
-                                                          logger_type_t *type)
+CALLBACK(logger_entry_match, bool,
+       logger_entry_t *this, va_list args)
 {
-       return this->type == *type && streq(this->target, target);
+       logger_type_t type;
+       char *target;
+
+       VA_ARGS_VGET(args, target, type);
+       return this->type == type && streq(this->target, target);
 }
 
 /**
@@ -350,8 +351,8 @@ static logger_entry_t *get_logger_entry(char *target, logger_type_t type,
 {
        logger_entry_t *entry;
 
-       if (existing->find_first(existing, (void*)logger_entry_match,
-                                                       (void**)&entry, target, &type) != SUCCESS)
+       if (!existing->find_first(existing, logger_entry_match, (void**)&entry,
+                                                         target, type))
        {
                INIT(entry,
                        .target = strdup(target),
index ea5af9e..3d736b2 100644 (file)
@@ -632,21 +632,18 @@ METHOD(kernel_interface_t, enable_udp_decap, bool,
 METHOD(kernel_interface_t, is_interface_usable, bool,
        private_kernel_interface_t *this, const char *iface)
 {
-       status_t expected;
-
        if (!this->ifaces_filter)
        {
                return TRUE;
        }
-       expected = this->ifaces_exclude ? NOT_FOUND : SUCCESS;
-       return this->ifaces_filter->find_first(this->ifaces_filter, (void*)streq,
-                                                                                  NULL, iface) == expected;
+       return this->ifaces_filter->find_first(this->ifaces_filter,
+                                       linked_list_match_str, NULL, iface) != this->ifaces_exclude;
 }
 
 METHOD(kernel_interface_t, all_interfaces_usable, bool,
        private_kernel_interface_t *this)
 {
-       return this->ifaces_filter == NULL;
+       return !this->ifaces_filter;
 }
 
 METHOD(kernel_interface_t, get_address_by_ts, status_t,
index e690028..644cff0 100644 (file)
@@ -110,15 +110,12 @@ static bool policy_equals(bypass_policy_t *a, bypass_policy_t *b)
  */
 static bool consider_interface(private_bypass_lan_listener_t *this, char *iface)
 {
-       status_t expected;
-
        if (!iface || !this->ifaces_filter)
        {
                return TRUE;
        }
-       expected = this->ifaces_exclude ? NOT_FOUND : SUCCESS;
-       return this->ifaces_filter->find_first(this->ifaces_filter, (void*)streq,
-                                                                                  NULL, iface) == expected;
+       return this->ifaces_filter->find_first(this->ifaces_filter,
+                                       linked_list_match_str, NULL, iface) != this->ifaces_exclude;
 }
 
 /**
index f0681b1..50ffbab 100644 (file)
@@ -151,8 +151,7 @@ METHOD(attribute_provider_t, create_attribute_enumerator, enumerator_t*,
        identification_t *id;
        host_t *vip;
 
-       if (pools->find_first(pools, (linked_list_match_t)streq,
-                                                 NULL, "dhcp") != SUCCESS)
+       if (!pools->find_first(pools, linked_list_match_str, NULL, "dhcp"))
        {
                return NULL;
        }
index 807c682..42f8f1e 100644 (file)
@@ -382,8 +382,7 @@ METHOD(dhcp_socket_t, enroll, dhcp_transaction_t*,
        while (try <= DHCP_TRIES && discover(this, transaction))
        {
                if (!this->condvar->timed_wait(this->condvar, this->mutex, 1000 * try) &&
-                       this->request->find_first(this->request, NULL,
-                                                                         (void**)&transaction) == SUCCESS)
+                       this->request->find_first(this->request, NULL, (void**)&transaction))
                {
                        break;
                }
index 83ccd3a..204fb31 100644 (file)
@@ -69,6 +69,15 @@ static bool entry_matches(eap_vendor_type_t *item, eap_vendor_type_t *other)
        return item->type == other->type && item->vendor == other->vendor;
 }
 
+CALLBACK(entry_matches_cb, bool,
+       eap_vendor_type_t *item, va_list args)
+{
+       eap_vendor_type_t *other;
+
+       VA_ARGS_VGET(args, other);
+       return entry_matches(item, other);
+}
+
 /**
  * Load the given EAP method
  */
@@ -121,8 +130,7 @@ static void select_method(private_eap_dynamic_t *this)
        {
                if (inner)
                {
-                       if (inner->find_first(inner, (void*)entry_matches,
-                                                                 NULL, entry) != SUCCESS)
+                       if (!inner->find_first(inner, entry_matches_cb, NULL, entry))
                        {
                                if (entry->vendor)
                                {
index 77e37e2..d4832e2 100644 (file)
@@ -84,12 +84,12 @@ static void exclude_route_destroy(exclude_route_t *this)
        free(this);
 }
 
-/**
- * Find an exclude route entry by destination address
- */
-static bool exclude_route_match(exclude_route_t *current,
-                                                               host_t *dst)
+CALLBACK(exclude_route_match, bool,
+       exclude_route_t *current, va_list args)
 {
+       host_t *dst;
+
+       VA_ARGS_VGET(args, dst);
        return dst->ip_equals(dst, current->dst);
 }
 
@@ -204,12 +204,12 @@ static void policy_entry_destroy(policy_entry_t *this)
        free(this);
 }
 
-/**
- * Compare two policy_entry_t objects
- */
-static inline bool policy_entry_equals(policy_entry_t *a,
-                                                                          policy_entry_t *b)
+CALLBACK(policy_entry_equals, bool,
+       policy_entry_t *a, va_list args)
 {
+       policy_entry_t *b;
+
+       VA_ARGS_VGET(args, b);
        return a->direction == b->direction &&
                   a->src.proto == b->src.proto &&
                   a->dst.proto == b->dst.proto &&
@@ -297,9 +297,8 @@ static void add_exclude_route(private_kernel_libipsec_ipsec_t *this,
        exclude_route_t *exclude;
        host_t *gtw;
 
-       if (this->excludes->find_first(this->excludes,
-                                                                 (linked_list_match_t)exclude_route_match,
-                                                                 (void**)&exclude, dst) == SUCCESS)
+       if (this->excludes->find_first(this->excludes, exclude_route_match,
+                                                                 (void**)&exclude, dst))
        {
                route->exclude = exclude;
                exclude->refs++;
@@ -524,9 +523,8 @@ METHOD(kernel_ipsec_t, add_policy, status_t,
        policy = create_policy_entry(id->src_ts, id->dst_ts, id->dir);
 
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                                 (linked_list_match_t)policy_entry_equals,
-                                                                 (void**)&found, policy) == SUCCESS)
+       if (this->policies->find_first(this->policies, policy_entry_equals,
+                                                                 (void**)&found, policy))
        {
                policy_entry_destroy(policy);
                policy = found;
@@ -567,9 +565,8 @@ METHOD(kernel_ipsec_t, del_policy, status_t,
        policy = create_policy_entry(id->src_ts, id->dst_ts, id->dir);
 
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                                 (linked_list_match_t)policy_entry_equals,
-                                                                 (void**)&found, policy) != SUCCESS)
+       if (!this->policies->find_first(this->policies, policy_entry_equals,
+                                                                       (void**)&found, policy))
        {
                policy_entry_destroy(policy);
                this->mutex->unlock(this->mutex);
index dd62044..0dd3e30 100644 (file)
@@ -163,19 +163,21 @@ static void iface_entry_destroy(iface_entry_t *this)
        free(this);
 }
 
-/**
- * find an interface entry by index
- */
-static bool iface_entry_by_index(iface_entry_t *this, int *ifindex)
+CALLBACK(iface_entry_by_index, bool,
+       iface_entry_t *this, va_list args)
 {
-       return this->ifindex == *ifindex;
+       int ifindex;
+
+       VA_ARGS_VGET(args, ifindex);
+       return this->ifindex == ifindex;
 }
 
-/**
- * find an interface entry by name
- */
-static bool iface_entry_by_name(iface_entry_t *this, char *ifname)
+CALLBACK(iface_entry_by_name, bool,
+       iface_entry_t *this, va_list args)
 {
+       char *ifname;
+
+       VA_ARGS_VGET(args, ifname);
        return streq(this->ifname, ifname);
 }
 
@@ -1112,8 +1114,8 @@ static bool is_interface_up_and_usable(private_kernel_netlink_net_t *this,
 {
        iface_entry_t *iface;
 
-       if (this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_index,
-                                                                (void**)&iface, &index) == SUCCESS)
+       if (this->ifaces->find_first(this->ifaces, iface_entry_by_index,
+                                                                (void**)&iface, index))
        {
                return iface_entry_up_and_usable(iface);
        }
@@ -1175,9 +1177,8 @@ static void process_link(private_kernel_netlink_net_t *this,
        {
                case RTM_NEWLINK:
                {
-                       if (this->ifaces->find_first(this->ifaces,
-                                                                       (void*)iface_entry_by_index, (void**)&entry,
-                                                                       &msg->ifi_index) != SUCCESS)
+                       if (!this->ifaces->find_first(this->ifaces, iface_entry_by_index,
+                                                                                (void**)&entry, msg->ifi_index))
                        {
                                INIT(entry,
                                        .ifindex = msg->ifi_index,
@@ -1292,8 +1293,8 @@ static void process_addr(private_kernel_netlink_net_t *this,
        }
 
        this->lock->write_lock(this->lock);
-       if (this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_index,
-                                                                (void**)&iface, &msg->ifa_index) == SUCCESS)
+       if (this->ifaces->find_first(this->ifaces, iface_entry_by_index,
+                                                                (void**)&iface, msg->ifa_index))
        {
                addr_map_entry_t *entry, lookup = {
                        .ip = host,
@@ -1674,8 +1675,8 @@ static int get_interface_index(private_kernel_netlink_net_t *this, char* name)
        DBG2(DBG_KNL, "getting iface index for %s", name);
 
        this->lock->read_lock(this->lock);
-       if (this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_name,
-                                                               (void**)&iface, name) == SUCCESS)
+       if (this->ifaces->find_first(this->ifaces, iface_entry_by_name,
+                                                               (void**)&iface, name))
        {
                ifindex = iface->ifindex;
        }
@@ -1700,8 +1701,8 @@ static char *get_interface_name_by_index(private_kernel_netlink_net_t *this,
        DBG2(DBG_KNL, "getting iface name for index %d", index);
 
        this->lock->read_lock(this->lock);
-       if (this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_index,
-                                                               (void**)&iface, &index) == SUCCESS)
+       if (this->ifaces->find_first(this->ifaces, iface_entry_by_index,
+                                                               (void**)&iface, index))
        {
                name = strdup(iface->ifname);
        }
@@ -1941,7 +1942,7 @@ static host_t *get_route(private_kernel_netlink_net_t *this, host_t *dest,
 
                                table = (uintptr_t)route->table;
                                if (this->rt_exclude->find_first(this->rt_exclude, NULL,
-                                                                                                (void**)&table) == SUCCESS)
+                                                                                                (void**)&table))
                                {       /* route is from an excluded routing table */
                                        continue;
                                }
@@ -2400,11 +2401,11 @@ METHOD(kernel_net_t, add_ip, status_t,
        }
        /* try to find the target interface, either by config or via src ip */
        if (!this->install_virtual_ip_on ||
-                this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_name,
-                                               (void**)&iface, this->install_virtual_ip_on) != SUCCESS)
+               !this->ifaces->find_first(this->ifaces, iface_entry_by_name,
+                                                                (void**)&iface, this->install_virtual_ip_on))
        {
-               if (this->ifaces->find_first(this->ifaces, (void*)iface_entry_by_name,
-                                                                        (void**)&iface, iface_name) != SUCCESS)
+               if (!this->ifaces->find_first(this->ifaces, iface_entry_by_name,
+                                                                        (void**)&iface, iface_name))
                {       /* if we don't find the requested interface we just use the first */
                        this->ifaces->get_first(this->ifaces, (void**)&iface);
                }
index 16dae6b..fd1adb2 100644 (file)
@@ -585,12 +585,12 @@ CALLBACK(policy_entry_destroy_cb, void,
        policy_entry_destroy(policy, this);
 }
 
-/**
- * compares two policy_entry_t
- */
-static inline bool policy_entry_equals(policy_entry_t *current,
-                                                                          policy_entry_t *policy)
+CALLBACK(policy_entry_equals, bool,
+       policy_entry_t *current, va_list args)
 {
+       policy_entry_t *policy;
+
+       VA_ARGS_VGET(args, policy);
        return current->direction == policy->direction &&
                   current->src.proto == policy->src.proto &&
                   current->dst.proto == policy->dst.proto &&
@@ -600,13 +600,13 @@ static inline bool policy_entry_equals(policy_entry_t *current,
                   current->dst.net->equals(current->dst.net, policy->dst.net);
 }
 
-/**
- * compare the given kernel index with that of a policy
- */
-static inline bool policy_entry_match_byindex(policy_entry_t *current,
-                                                                                         uint32_t *index)
+CALLBACK(policy_entry_match_byindex, bool,
+       policy_entry_t *current, va_list args)
 {
-       return current->index == *index;
+       uint32_t index;
+
+       VA_ARGS_VGET(args, index);
+       return current->index == index;
 }
 
 /**
@@ -1279,9 +1279,8 @@ static void process_acquire(private_kernel_pfkey_ipsec_t *this,
 
        index = response.x_policy->sadb_x_policy_id;
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                               (linked_list_match_t)policy_entry_match_byindex,
-                                                               (void**)&policy, &index) == SUCCESS &&
+       if (this->policies->find_first(this->policies, policy_entry_match_byindex,
+                                                                 (void**)&policy, index) &&
                policy->used_by->get_first(policy->used_by, (void**)&sa) == SUCCESS)
        {
                reqid = sa->sa->cfg.reqid;
@@ -2572,8 +2571,7 @@ static status_t add_policy_internal(private_kernel_pfkey_ipsec_t *this,
 
        /* we try to find the policy again and update the kernel index */
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies, NULL,
-                                                                 (void**)&policy) != SUCCESS)
+       if (!this->policies->find_first(this->policies, NULL, (void**)&policy))
        {
                DBG2(DBG_KNL, "unable to update index, the policy is already gone, "
                                          "ignoring");
@@ -2624,9 +2622,8 @@ METHOD(kernel_ipsec_t, add_policy, status_t,
 
        /* find a matching policy */
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                                 (linked_list_match_t)policy_entry_equals,
-                                                                 (void**)&found, policy) == SUCCESS)
+       if (this->policies->find_first(this->policies, policy_entry_equals,
+                                                                  (void**)&found, policy))
        {       /* use existing policy */
                DBG2(DBG_KNL, "policy %R === %R %N already exists, increasing "
                         "refcount", id->src_ts, id->dst_ts, policy_dir_names, id->dir);
@@ -2719,9 +2716,8 @@ METHOD(kernel_ipsec_t, query_policy, status_t,
 
        /* find a matching policy */
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                                 (linked_list_match_t)policy_entry_equals,
-                                                                 (void**)&found, policy) != SUCCESS)
+       if (!this->policies->find_first(this->policies, policy_entry_equals,
+                                                                       (void**)&found, policy))
        {
                DBG1(DBG_KNL, "querying policy %R === %R %N failed, not found",
                         id->src_ts, id->dst_ts, policy_dir_names, id->dir);
@@ -2832,9 +2828,8 @@ METHOD(kernel_ipsec_t, del_policy, status_t,
 
        /* find a matching policy */
        this->mutex->lock(this->mutex);
-       if (this->policies->find_first(this->policies,
-                                                                 (linked_list_match_t)policy_entry_equals,
-                                                                 (void**)&found, policy) != SUCCESS)
+       if (!this->policies->find_first(this->policies, policy_entry_equals,
+                                                                       (void**)&found, policy))
        {
                DBG1(DBG_KNL, "deleting policy %R === %R %N failed, not found",
                         id->src_ts, id->dst_ts, policy_dir_names, id->dir);
index 880e80a..cdf2660 100644 (file)
@@ -106,12 +106,13 @@ METHOD(enumerator_t, enumerate_attrs, bool,
        return FALSE;
 }
 
-/**
- * Check if the given host has a matching address family
- */
-static bool is_family(host_t *host, int *family)
+CALLBACK(is_family, bool,
+       host_t *host, va_list args)
 {
-       return host->get_family(host) == *family;
+       int family;
+
+       VA_ARGS_VGET(args, family);
+       return host->get_family(host) == family;
 }
 
 /**
@@ -119,7 +120,7 @@ static bool is_family(host_t *host, int *family)
  */
 static bool has_host_family(linked_list_t *list, int family)
 {
-       return list->find_first(list, (void*)is_family, NULL, &family) == SUCCESS;
+       return list->find_first(list, is_family, NULL, family);
 }
 
 METHOD(attribute_handler_t, create_attribute_enumerator, enumerator_t *,
index 0a20188..4593e9b 100644 (file)
@@ -358,11 +358,12 @@ METHOD(credential_set_t, create_cdp_enumerator, enumerator_t*,
                        data, (void*)cdp_data_destroy);
 }
 
-/**
- * Compare the given certificate to the ca_cert_t items in the list
- */
-static bool match_cert(ca_cert_t *item, certificate_t *cert)
+CALLBACK(match_cert, bool,
+       ca_cert_t *item, va_list args)
 {
+       certificate_t *cert;
+
+       VA_ARGS_VGET(args, cert);
        return cert->equals(cert, item->cert);
 }
 
@@ -409,8 +410,7 @@ static certificate_t *add_cert_internal(private_stroke_ca_t *this,
 {
        ca_cert_t *found;
 
-       if (this->certs->find_first(this->certs, (linked_list_match_t)match_cert,
-                                                               (void**)&found, cert) == SUCCESS)
+       if (this->certs->find_first(this->certs, match_cert, (void**)&found, cert))
        {
                cert->destroy(cert);
                cert = found->cert->get_ref(found->cert);
@@ -515,8 +515,7 @@ METHOD(stroke_ca_t, get_cert_ref, certificate_t*,
        ca_cert_t *found;
 
        this->lock->read_lock(this->lock);
-       if (this->certs->find_first(this->certs, (linked_list_match_t)match_cert,
-                                                               (void**)&found, cert) == SUCCESS)
+       if (this->certs->find_first(this->certs, match_cert, (void**)&found, cert))
        {
                cert->destroy(cert);
                cert = found->cert->get_ref(found->cert);
index a333166..2299259 100644 (file)
@@ -958,8 +958,7 @@ static void list_plugins(FILE *out)
                                {
                                        case FEATURE_PROVIDE:
                                                fp = &features[i];
-                                               loaded = list->find_first(list, NULL,
-                                                                                                 (void**)&fp) == SUCCESS;
+                                               loaded = list->find_first(list, NULL, (void**)&fp);
                                                fprintf(out, "    %s%s\n",
                                                                str, loaded ? "" : " (not loaded)");
                                                break;
index c6b5494..c0bfebb 100644 (file)
@@ -151,8 +151,10 @@ static entry_t *entry_create()
 /**
  * Function that matches entry_t objects by ike_sa_id_t.
  */
-static bool entry_match_by_id(entry_t *entry, ike_sa_id_t *id)
+static bool entry_match_by_id(entry_t *entry, void *arg)
 {
+       ike_sa_id_t *id = arg;
+
        if (id->equals(id, entry->ike_sa_id))
        {
                return TRUE;
@@ -172,7 +174,7 @@ static bool entry_match_by_id(entry_t *entry, ike_sa_id_t *id)
 /**
  * Function that matches entry_t objects by ike_sa_t pointers.
  */
-static bool entry_match_by_sa(entry_t *entry, ike_sa_t *ike_sa)
+static bool entry_match_by_sa(entry_t *entry, void *ike_sa)
 {
        return entry->ike_sa == ike_sa;
 }
@@ -677,7 +679,7 @@ static void remove_entry_at(private_enumerator_t *this)
  */
 static status_t get_entry_by_match_function(private_ike_sa_manager_t *this,
                                        ike_sa_id_t *ike_sa_id, entry_t **entry, u_int *segment,
-                                       linked_list_match_t match, void *param)
+                                       bool (*match)(entry_t*,void*), void *param)
 {
        table_item_t *item;
        u_int row, seg;
@@ -710,7 +712,7 @@ static status_t get_entry_by_id(private_ike_sa_manager_t *this,
                                                ike_sa_id_t *ike_sa_id, entry_t **entry, u_int *segment)
 {
        return get_entry_by_match_function(this, ike_sa_id, entry, segment,
-                               (linked_list_match_t)entry_match_by_id, ike_sa_id);
+                                                                          entry_match_by_id, ike_sa_id);
 }
 
 /**
@@ -721,7 +723,7 @@ static status_t get_entry_by_sa(private_ike_sa_manager_t *this,
                        ike_sa_id_t *ike_sa_id, ike_sa_t *ike_sa, entry_t **entry, u_int *segment)
 {
        return get_entry_by_match_function(this, ike_sa_id, entry, segment,
-                               (linked_list_match_t)entry_match_by_sa, ike_sa);
+                                                                          entry_match_by_sa, ike_sa);
 }
 
 /**
@@ -858,6 +860,15 @@ static void remove_half_open(private_ike_sa_manager_t *this, entry_t *entry)
        lock->unlock(lock);
 }
 
+CALLBACK(id_matches, bool,
+       ike_sa_id_t *a, va_list args)
+{
+       ike_sa_id_t *b;
+
+       VA_ARGS_VGET(args, b);
+       return a->equals(a, b);
+}
+
 /**
  * Put an SA between two peers into the hash table.
  */
@@ -886,8 +897,7 @@ static void put_connected_peers(private_ike_sa_manager_t *this, entry_t *entry)
                                                                  entry->other_id, family))
                {
                        if (connected_peers->sas->find_first(connected_peers->sas,
-                                       (linked_list_match_t)entry->ike_sa_id->equals,
-                                       NULL, entry->ike_sa_id) == SUCCESS)
+                                                                                       id_matches, NULL, entry->ike_sa_id))
                        {
                                lock->unlock(lock);
                                return;
index 280796d..3585678 100644 (file)
@@ -450,22 +450,21 @@ static initiate_data_t *initiate_data_create(check_list_t *checklist,
        return this;
 }
 
-/**
- * Find an initiated connection by the peers' ids
- */
-static bool match_initiated_by_ids(initiated_t *current, identification_t *id,
-                                                                  identification_t *peer_id)
+CALLBACK(match_initiated_by_ids, bool,
+       initiated_t *current, va_list args)
 {
+       identification_t *id, *peer_id;
+
+       VA_ARGS_VGET(args, id, peer_id);
        return id->equals(id, current->id) && peer_id->equals(peer_id, current->peer_id);
 }
 
-static status_t get_initiated_by_ids(private_connect_manager_t *this,
-                                                                        identification_t *id,
-                                                                        identification_t *peer_id,
-                                                                        initiated_t **initiated)
+static bool get_initiated_by_ids(private_connect_manager_t *this,
+                                                                identification_t *id,
+                                                                identification_t *peer_id,
+                                                                initiated_t **initiated)
 {
-       return this->initiated->find_first(this->initiated,
-                                                               (linked_list_match_t)match_initiated_by_ids,
+       return this->initiated->find_first(this->initiated, match_initiated_by_ids,
                                                                (void**)initiated, id, peer_id);
 }
 
@@ -490,21 +489,20 @@ static void remove_initiated(private_connect_manager_t *this,
        enumerator->destroy(enumerator);
 }
 
-/**
- * Find the checklist with a specific connect ID
- */
-static bool match_checklist_by_id(check_list_t *current, chunk_t *connect_id)
+CALLBACK(match_checklist_by_id, bool,
+       check_list_t *current, va_list args)
 {
-       return chunk_equals(*connect_id, current->connect_id);
+       chunk_t connect_id;
+
+       VA_ARGS_VGET(args, connect_id);
+       return chunk_equals(connect_id, current->connect_id);
 }
 
-static status_t get_checklist_by_id(private_connect_manager_t *this,
-                                                                       chunk_t connect_id,
-                                                                       check_list_t **check_list)
+static bool get_checklist_by_id(private_connect_manager_t *this,
+                                                               chunk_t connect_id, check_list_t **check_list)
 {
-       return this->checklists->find_first(this->checklists,
-                                                               (linked_list_match_t)match_checklist_by_id,
-                                                               (void**)check_list, &connect_id);
+       return this->checklists->find_first(this->checklists, match_checklist_by_id,
+                                                                               (void**)check_list, connect_id);
 }
 
 /**
@@ -528,19 +526,19 @@ static void remove_checklist(private_connect_manager_t *this,
        enumerator->destroy(enumerator);
 }
 
-/**
- * Checks if a list of endpoint_notify_t contains a certain host_t
- */
-static bool match_endpoint_by_host(endpoint_notify_t *current, host_t *host)
+CALLBACK(match_endpoint_by_host, bool,
+       endpoint_notify_t *current, va_list args)
 {
+       host_t *host;
+
+       VA_ARGS_VGET(args, host);
        return host->equals(host, current->get_host(current));
 }
 
-static status_t endpoints_contain(linked_list_t *endpoints, host_t *host,
+static bool endpoints_contain(linked_list_t *endpoints, host_t *host,
                                                                  endpoint_notify_t **endpoint)
 {
-       return endpoints->find_first(endpoints,
-                                                                (linked_list_match_t)match_endpoint_by_host,
+       return endpoints->find_first(endpoints, match_endpoint_by_host,
                                                                 (void**)endpoint, host);
 }
 
@@ -560,39 +558,44 @@ static void insert_pair_by_priority(linked_list_t *pairs, endpoint_pair_t *pair)
        enumerator->destroy(enumerator);
 }
 
-/**
- * Searches a list of endpoint_pair_t for a pair with specific host_ts
- */
-static bool match_pair_by_hosts(endpoint_pair_t *current, host_t *local,
-                                                               host_t *remote)
+CALLBACK(match_pair_by_hosts, bool,
+       endpoint_pair_t *current, va_list args)
 {
-       return local->equals(local, current->local) && remote->equals(remote, current->remote);
+       host_t *local, *remote;
+
+       VA_ARGS_VGET(args, local, remote);
+       return local->equals(local, current->local) &&
+                  remote->equals(remote, current->remote);
 }
 
-static status_t get_pair_by_hosts(linked_list_t *pairs, host_t *local,
-                                                                 host_t *remote, endpoint_pair_t **pair)
+static bool get_pair_by_hosts(linked_list_t *pairs, host_t *local,
+                                                         host_t *remote, endpoint_pair_t **pair)
 {
-       return pairs->find_first(pairs, (linked_list_match_t)match_pair_by_hosts,
-                                                        (void**)pair, local, remote);
+       return pairs->find_first(pairs, match_pair_by_hosts, (void**)pair, local,
+                                                        remote);
 }
 
-static bool match_pair_by_id(endpoint_pair_t *current, uint32_t *id)
+CALLBACK(match_pair_by_id, bool,
+       endpoint_pair_t *current, va_list args)
 {
-       return current->id == *id;
+       uint32_t id;
+
+       VA_ARGS_VGET(args, id);
+       return current->id == id;
 }
 
 /**
  * Searches for a pair with a specific id
  */
-static status_t get_pair_by_id(check_list_t *checklist, uint32_t id,
-                                                          endpoint_pair_t **pair)
+static bool get_pair_by_id(check_list_t *checklist, uint32_t id,
+                                                  endpoint_pair_t **pair)
 {
-       return checklist->pairs->find_first(checklist->pairs,
-                                                                               (linked_list_match_t)match_pair_by_id,
-                                                                               (void**)pair, &id);
+       return checklist->pairs->find_first(checklist->pairs, match_pair_by_id,
+                                                                               (void**)pair, id);
 }
 
-static bool match_succeeded_pair(endpoint_pair_t *current)
+CALLBACK(match_succeeded_pair, bool,
+       endpoint_pair_t *current, va_list args)
 {
        return current->state == CHECK_SUCCEEDED;
 }
@@ -600,15 +603,14 @@ static bool match_succeeded_pair(endpoint_pair_t *current)
 /**
  * Returns the best pair of state CHECK_SUCCEEDED from a checklist.
  */
-static status_t get_best_valid_pair(check_list_t *checklist,
-                                                                       endpoint_pair_t **pair)
+static bool get_best_valid_pair(check_list_t *checklist, endpoint_pair_t **pair)
 {
-       return checklist->pairs->find_first(checklist->pairs,
-                                                                       (linked_list_match_t)match_succeeded_pair,
-                                                                       (void**)pair);
+       return checklist->pairs->find_first(checklist->pairs, match_succeeded_pair,
+                                                                               (void**)pair);
 }
 
-static bool match_waiting_pair(endpoint_pair_t *current)
+CALLBACK(match_waiting_pair, bool,
+       endpoint_pair_t *current, va_list args)
 {
        return current->state == CHECK_WAITING;
 }
@@ -865,7 +867,7 @@ static job_requeue_t initiator_finish(callback_data_t *data)
        this->mutex->lock(this->mutex);
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, data->connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found, can't finish "
                         "connectivity checks", &data->connect_id);
@@ -953,7 +955,7 @@ static job_requeue_t retransmit(callback_data_t *data)
        this->mutex->lock(this->mutex);
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, data->connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found, can't retransmit "
                         "connectivity check", &data->connect_id);
@@ -962,7 +964,7 @@ static job_requeue_t retransmit(callback_data_t *data)
        }
 
        endpoint_pair_t *pair;
-       if (get_pair_by_id(checklist, data->mid, &pair) != SUCCESS)
+       if (!get_pair_by_id(checklist, data->mid, &pair))
        {
                DBG1(DBG_IKE, "pair with id '%d' not found, can't retransmit "
                         "connectivity check", data->mid);
@@ -1108,7 +1110,7 @@ static job_requeue_t sender(callback_data_t *data)
        this->mutex->lock(this->mutex);
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, data->connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, data->connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found, can't send "
                         "connectivity check", &data->connect_id);
@@ -1124,9 +1126,8 @@ static job_requeue_t sender(callback_data_t *data)
        {
                DBG1(DBG_IKE, "no triggered check queued, sending an ordinary check");
 
-               if (checklist->pairs->find_first(checklist->pairs,
-                                                                       (linked_list_match_t)match_waiting_pair,
-                                                                       (void**)&pair) != SUCCESS)
+               if (!checklist->pairs->find_first(checklist->pairs, match_waiting_pair,
+                                                                                 (void**)&pair))
                {
                        this->mutex->unlock(this->mutex);
                        DBG1(DBG_IKE, "no pairs in waiting state, aborting");
@@ -1182,7 +1183,7 @@ static job_requeue_t initiate_mediated(initiate_data_t *data)
        initiated_t *initiated = data->initiated;
 
        endpoint_pair_t *pair;
-       if (get_best_valid_pair(checklist, &pair) == SUCCESS)
+       if (get_best_valid_pair(checklist, &pair))
        {
                ike_sa_id_t *waiting_sa;
                enumerator_t *enumerator = initiated->mediated->create_enumerator(
@@ -1219,7 +1220,7 @@ static void finish_checks(private_connect_manager_t *this, check_list_t *checkli
        {
                initiated_t *initiated;
                if (get_initiated_by_ids(this, checklist->initiator.id,
-                               checklist->responder.id, &initiated) == SUCCESS)
+                                                                checklist->responder.id, &initiated))
                {
                        callback_job_t *job;
 
@@ -1247,7 +1248,7 @@ static void process_response(private_connect_manager_t *this, check_t *check,
                check_list_t *checklist)
 {
        endpoint_pair_t *pair;
-       if (get_pair_by_id(checklist, check->mid, &pair) == SUCCESS)
+       if (get_pair_by_id(checklist, check->mid, &pair))
        {
                if (pair->local->equals(pair->local, check->dst) &&
                        pair->remote->equals(pair->remote, check->src))
@@ -1261,9 +1262,9 @@ static void process_response(private_connect_manager_t *this, check_t *check,
                        checklist->initiator.endpoints : checklist->responder.endpoints;
 
                endpoint_notify_t *local_endpoint;
-               if (endpoints_contain(local_endpoints,
-                                                         check->endpoint->get_host(check->endpoint),
-                                                         &local_endpoint) != SUCCESS)
+               if (!endpoints_contain(local_endpoints,
+                                                          check->endpoint->get_host(check->endpoint),
+                                                          &local_endpoint))
                {
                        local_endpoint = endpoint_notify_create_from_host(PEER_REFLEXIVE,
                                        check->endpoint->get_host(check->endpoint), pair->local);
@@ -1302,15 +1303,14 @@ static void process_request(private_connect_manager_t *this, check_t *check,
        peer_reflexive->set_priority(peer_reflexive,
                                                        check->endpoint->get_priority(check->endpoint));
 
-       if (endpoints_contain(remote_endpoints, check->src, &remote_endpoint) != SUCCESS)
+       if (!endpoints_contain(remote_endpoints, check->src, &remote_endpoint))
        {
                remote_endpoint = peer_reflexive->clone(peer_reflexive);
                remote_endpoints->insert_last(remote_endpoints, remote_endpoint);
        }
 
        endpoint_pair_t *pair;
-       if (get_pair_by_hosts(checklist->pairs, check->dst, check->src,
-                                                 &pair) == SUCCESS)
+       if (get_pair_by_hosts(checklist->pairs, check->dst, check->src, &pair))
        {
                switch(pair->state)
                {
@@ -1389,7 +1389,7 @@ METHOD(connect_manager_t, process_check, void,
        this->mutex->lock(this->mutex);
 
        check_list_t *checklist;
-       if (get_checklist_by_id(this, check->connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, check->connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found",
                         &check->connect_id);
@@ -1423,6 +1423,15 @@ METHOD(connect_manager_t, process_check, void,
        check_destroy(check);
 }
 
+CALLBACK(id_matches, bool,
+       ike_sa_id_t *a, va_list args)
+{
+       ike_sa_id_t *b;
+
+       VA_ARGS_VGET(args, b);
+       return a->equals(a, b);
+}
+
 METHOD(connect_manager_t, check_and_register, bool,
        private_connect_manager_t *this, identification_t *id,
        identification_t *peer_id, ike_sa_id_t *mediated_sa)
@@ -1432,7 +1441,7 @@ METHOD(connect_manager_t, check_and_register, bool,
 
        this->mutex->lock(this->mutex);
 
-       if (get_initiated_by_ids(this, id, peer_id, &initiated) != SUCCESS)
+       if (!get_initiated_by_ids(this, id, peer_id, &initiated))
        {
                DBG2(DBG_IKE, "registered waiting mediated connection with '%Y'",
                         peer_id);
@@ -1441,9 +1450,8 @@ METHOD(connect_manager_t, check_and_register, bool,
                already_there = FALSE;
        }
 
-       if (initiated->mediated->find_first(initiated->mediated,
-                                                               (linked_list_match_t)mediated_sa->equals,
-                                                               NULL, mediated_sa) != SUCCESS)
+       if (!initiated->mediated->find_first(initiated->mediated, id_matches,
+                                                                                NULL, mediated_sa))
        {
                initiated->mediated->insert_last(initiated->mediated,
                                                                                 mediated_sa->clone(mediated_sa));
@@ -1462,7 +1470,7 @@ METHOD(connect_manager_t, check_and_initiate, void,
 
        this->mutex->lock(this->mutex);
 
-       if (get_initiated_by_ids(this, id, peer_id, &initiated) != SUCCESS)
+       if (!get_initiated_by_ids(this, id, peer_id, &initiated))
        {
                DBG2(DBG_IKE, "no waiting mediated connections with '%Y'", peer_id);
                this->mutex->unlock(this->mutex);
@@ -1492,7 +1500,7 @@ METHOD(connect_manager_t, set_initiator_data, status_t,
 
        this->mutex->lock(this->mutex);
 
-       if (get_checklist_by_id(this, connect_id, NULL) == SUCCESS)
+       if (get_checklist_by_id(this, connect_id, NULL))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' already exists, aborting",
                         &connect_id);
@@ -1517,7 +1525,7 @@ METHOD(connect_manager_t, set_responder_data, status_t,
 
        this->mutex->lock(this->mutex);
 
-       if (get_checklist_by_id(this, connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found",
                         &connect_id);
@@ -1547,7 +1555,7 @@ METHOD(connect_manager_t, stop_checks, status_t,
 
        this->mutex->lock(this->mutex);
 
-       if (get_checklist_by_id(this, connect_id, &checklist) != SUCCESS)
+       if (!get_checklist_by_id(this, connect_id, &checklist))
        {
                DBG1(DBG_IKE, "checklist with id '%#B' not found",
                         &connect_id);
index 1608656..6267963 100644 (file)
@@ -81,11 +81,12 @@ typedef struct {
        bool check_delete_action;
 } entry_t;
 
-/**
- * Check if the given entry is for the same CHILD_SA
- */
-static bool match_child(entry_t *entry, child_sa_t *child_sa)
+CALLBACK(match_child, bool,
+       entry_t *entry, va_list args)
 {
+       child_sa_t *child_sa;
+
+       VA_ARGS_VGET(args, child_sa);
        return entry->child_sa == child_sa;
 }
 
@@ -252,8 +253,8 @@ static void process_payloads(private_child_delete_t *this, message_t *message)
                                DBG1(DBG_IKE, "received DELETE for %N CHILD_SA with SPI %.8x",
                                         protocol_id_names, protocol, ntohl(spi));
 
-                               if (this->child_sas->find_first(this->child_sas,
-                                                               (void*)match_child, NULL, child_sa) == SUCCESS)
+                               if (this->child_sas->find_first(this->child_sas, match_child,
+                                                                                               NULL, child_sa))
                                {
                                        continue;
                                }
index 71190f3..f9fee5e 100644 (file)
@@ -140,19 +140,21 @@ static void destroy_acquire(acquire_t *this)
        free(this);
 }
 
-/**
- * match an acquire entry by reqid
- */
-static bool acquire_by_reqid(acquire_t *this, uint32_t *reqid)
+CALLBACK(acquire_by_reqid, bool,
+       acquire_t *this, va_list args)
 {
-       return this->reqid == *reqid;
+       uint32_t reqid;
+
+       VA_ARGS_VGET(args, reqid);
+       return this->reqid == reqid;
 }
 
-/**
- * match an acquire entry by destination address
- */
-static bool acquire_by_dst(acquire_t *this, host_t *dst)
+CALLBACK(acquire_by_dst, bool,
+       acquire_t *this, va_list args)
 {
+       host_t *dst;
+
+       VA_ARGS_VGET(args, dst);
        return this->dst && this->dst->ip_equals(this->dst, dst);
 }
 
@@ -439,8 +441,8 @@ METHOD(trap_manager_t, acquire, void,
                uint8_t mask;
 
                dst->to_subnet(dst, &host, &mask);
-               if (this->acquires->find_first(this->acquires, (void*)acquire_by_dst,
-                                                                         (void**)&acquire, host) == SUCCESS)
+               if (this->acquires->find_first(this->acquires, acquire_by_dst,
+                                                                         (void**)&acquire, host))
                {
                        host->destroy(host);
                        ignore = TRUE;
@@ -456,8 +458,8 @@ METHOD(trap_manager_t, acquire, void,
        }
        else
        {
-               if (this->acquires->find_first(this->acquires, (void*)acquire_by_reqid,
-                                                                         (void**)&acquire, &reqid) == SUCCESS)
+               if (this->acquires->find_first(this->acquires, acquire_by_reqid,
+                                                                         (void**)&acquire, reqid))
                {
                        ignore = TRUE;
                }
index a1fa23e..957d930 100644 (file)
@@ -224,42 +224,60 @@ static void flush_entries(private_ipsec_sa_mgr_t *this)
        enumerator->destroy(enumerator);
 }
 
-/*
- * Different match functions to find SAs in the linked list
- */
-static bool match_entry_by_ptr(ipsec_sa_entry_t *item, ipsec_sa_entry_t *entry)
+CALLBACK(match_entry_by_sa_ptr, bool,
+       ipsec_sa_entry_t *item, va_list args)
 {
-       return item == entry;
-}
+       ipsec_sa_t *sa;
 
-static bool match_entry_by_sa_ptr(ipsec_sa_entry_t *item, ipsec_sa_t *sa)
-{
+       VA_ARGS_VGET(args, sa);
        return item->sa == sa;
 }
 
-static bool match_entry_by_spi_inbound(ipsec_sa_entry_t *item, uint32_t *spi,
-                                                                          bool *inbound)
+CALLBACK(match_entry_by_spi_inbound, bool,
+       ipsec_sa_entry_t *item, va_list args)
 {
-       return item->sa->get_spi(item->sa) == *spi &&
-                  item->sa->is_inbound(item->sa) == *inbound;
+       uint32_t spi;
+       int inbound;
+
+       VA_ARGS_VGET(args, spi, inbound);
+       return item->sa->get_spi(item->sa) == spi &&
+                  item->sa->is_inbound(item->sa) == inbound;
 }
 
-static bool match_entry_by_spi_src_dst(ipsec_sa_entry_t *item, uint32_t *spi,
+static bool match_entry_by_spi_src_dst(ipsec_sa_entry_t *item, uint32_t spi,
                                                                           host_t *src, host_t *dst)
 {
-       return item->sa->match_by_spi_src_dst(item->sa, *spi, src, dst);
+       return item->sa->match_by_spi_src_dst(item->sa, spi, src, dst);
 }
 
-static bool match_entry_by_reqid_inbound(ipsec_sa_entry_t *item,
-                                                                                uint32_t *reqid, bool *inbound)
+CALLBACK(match_entry_by_spi_src_dst_cb, bool,
+       ipsec_sa_entry_t *item, va_list args)
 {
-       return item->sa->match_by_reqid(item->sa, *reqid, *inbound);
+       host_t *src, *dst;
+       uint32_t spi;
+
+       VA_ARGS_VGET(args, spi, src, dst);
+       return match_entry_by_spi_src_dst(item, spi, src, dst);
+}
+
+CALLBACK(match_entry_by_reqid_inbound, bool,
+       ipsec_sa_entry_t *item, va_list args)
+{
+       uint32_t reqid;
+       int inbound;
+
+       VA_ARGS_VGET(args, reqid, inbound);
+       return item->sa->match_by_reqid(item->sa, reqid, inbound);
 }
 
-static bool match_entry_by_spi_dst(ipsec_sa_entry_t *item, uint32_t *spi,
-                                                                  host_t *dst)
+CALLBACK(match_entry_by_spi_dst, bool,
+       ipsec_sa_entry_t *item, va_list args)
 {
-       return item->sa->match_by_spi_dst(item->sa, *spi, dst);
+       host_t *dst;
+       uint32_t spi;
+
+       VA_ARGS_VGET(args, spi, dst);
+       return item->sa->match_by_spi_dst(item->sa, spi, dst);
 }
 
 /**
@@ -296,8 +314,7 @@ static job_requeue_t sa_expired(ipsec_sa_expired_t *expired)
        private_ipsec_sa_mgr_t *this = expired->manager;
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_ptr,
-                                                         NULL, expired->entry) == SUCCESS)
+       if (this->sas->find_first(this->sas, NULL, (void**)&expired->entry))
        {
                uint32_t hard_offset;
 
@@ -383,8 +400,8 @@ static bool allocate_spi(private_ipsec_sa_mgr_t *this, uint32_t spi)
        uint32_t *spi_alloc;
 
        if (this->allocated_spis->get(this->allocated_spis, &spi) ||
-               this->sas->find_first(this->sas, (void*)match_entry_by_spi_inbound,
-                                                         NULL, &spi, TRUE) == SUCCESS)
+               this->sas->find_first(this->sas, match_entry_by_spi_inbound,
+                                                         NULL, spi, TRUE))
        {
                return FALSE;
        }
@@ -484,8 +501,8 @@ METHOD(ipsec_sa_mgr_t, add_sa, status_t,
                free(spi_alloc);
        }
 
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_spi_src_dst,
-                                                         NULL, &spi, src, dst) == SUCCESS)
+       if (this->sas->find_first(this->sas, match_entry_by_spi_src_dst_cb, NULL,
+                                                         spi, src, dst))
        {
                this->mutex->unlock(this->mutex);
                DBG1(DBG_ESP, "failed to install SAD entry: already installed");
@@ -519,8 +536,8 @@ METHOD(ipsec_sa_mgr_t, update_sa, status_t,
        }
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_spi_src_dst,
-                                                        (void**)&entry, &spi, src, dst) == SUCCESS &&
+       if (this->sas->find_first(this->sas, match_entry_by_spi_src_dst_cb,
+                                                        (void**)&entry, spi, src, dst) &&
                wait_for_entry(this, entry))
        {
                entry->sa->set_source(entry->sa, new_src);
@@ -547,8 +564,8 @@ METHOD(ipsec_sa_mgr_t, query_sa, status_t,
        ipsec_sa_entry_t *entry = NULL;
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_spi_src_dst,
-                                                        (void**)&entry, &spi, src, dst) == SUCCESS &&
+       if (this->sas->find_first(this->sas, match_entry_by_spi_src_dst_cb,
+                                                        (void**)&entry, spi, src, dst) &&
                wait_for_entry(this, entry))
        {
                entry->sa->get_usestats(entry->sa, bytes, packets, time);
@@ -572,7 +589,7 @@ METHOD(ipsec_sa_mgr_t, del_sa, status_t,
        enumerator = this->sas->create_enumerator(this->sas);
        while (enumerator->enumerate(enumerator, (void**)&current))
        {
-               if (match_entry_by_spi_src_dst(current, &spi, src, dst))
+               if (match_entry_by_spi_src_dst(current, spi, src, dst))
                {
                        if (wait_remove_entry(this, current))
                        {
@@ -602,8 +619,8 @@ METHOD(ipsec_sa_mgr_t, checkout_by_reqid, ipsec_sa_t*,
        ipsec_sa_t *sa = NULL;
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_reqid_inbound,
-                                                        (void**)&entry, &reqid, &inbound) == SUCCESS &&
+       if (this->sas->find_first(this->sas, match_entry_by_reqid_inbound,
+                                                        (void**)&entry, reqid, inbound) &&
                wait_for_entry(this, entry))
        {
                sa = entry->sa;
@@ -619,8 +636,8 @@ METHOD(ipsec_sa_mgr_t, checkout_by_spi, ipsec_sa_t*,
        ipsec_sa_t *sa = NULL;
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_spi_dst,
-                                                        (void**)&entry, &spi, dst) == SUCCESS &&
+       if (this->sas->find_first(this->sas, match_entry_by_spi_dst,
+                                                        (void**)&entry, spi, dst) &&
                wait_for_entry(this, entry))
        {
                sa = entry->sa;
@@ -635,8 +652,8 @@ METHOD(ipsec_sa_mgr_t, checkin, void,
        ipsec_sa_entry_t *entry;
 
        this->mutex->lock(this->mutex);
-       if (this->sas->find_first(this->sas, (void*)match_entry_by_sa_ptr,
-                                                        (void**)&entry, sa) == SUCCESS)
+       if (this->sas->find_first(this->sas, match_entry_by_sa_ptr,
+                                                        (void**)&entry, sa))
        {
                if (entry->locked)
                {
index 5fcf8bc..f877be5 100644 (file)
@@ -47,6 +47,17 @@ struct element_t {
        element_t *next;
 };
 
+/*
+ * Described in header
+ */
+bool linked_list_match_str(void *item, va_list args)
+{
+       char *a = item, *b;
+
+       VA_ARGS_VGET(args, b);
+       return streq(a, b);
+}
+
 /**
  * Creates an empty linked list object.
  */
@@ -371,26 +382,41 @@ METHOD(linked_list_t, remove_at, void,
        }
 }
 
-METHOD(linked_list_t, find_first, status_t,
-       private_linked_list_t *this, linked_list_match_t match,
-       void **item, void *d1, void *d2, void *d3, void *d4, void *d5)
+METHOD(linked_list_t, find_first, bool,
+       private_linked_list_t *this, linked_list_match_t match, void **item, ...)
 {
        element_t *current = this->first;
+       va_list args;
+       bool matched = FALSE;
+
+       if (!match && !item)
+       {
+               return FALSE;
+       }
 
        while (current)
        {
-               if ((match && match(current->value, d1, d2, d3, d4, d5)) ||
-                       (!match && item && current->value == *item))
+               if (match)
+               {
+                       va_start(args, item);
+                       matched = match(current->value, args);
+                       va_end(args);
+               }
+               else
+               {
+                       matched = current->value == *item;
+               }
+               if (matched)
                {
                        if (item != NULL)
                        {
                                *item = current->value;
                        }
-                       return SUCCESS;
+                       return TRUE;
                }
                current = current->next;
        }
-       return NOT_FOUND;
+       return FALSE;
 }
 
 METHOD(linked_list_t, invoke_offset, void,
@@ -548,7 +574,7 @@ linked_list_t *linked_list_create()
                        .reset_enumerator = (void*)_reset_enumerator,
                        .get_first = _get_first,
                        .get_last = _get_last,
-                       .find_first = (void*)_find_first,
+                       .find_first = _find_first,
                        .insert_first = _insert_first,
                        .insert_last = _insert_last,
                        .insert_before = (void*)_insert_before,
index 3f80cd8..246b9a5 100644 (file)
@@ -28,15 +28,22 @@ typedef struct linked_list_t linked_list_t;
 #include <collections/enumerator.h>
 
 /**
- * Method to match elements in a linked list (used in find_* functions)
+ * Function to match elements in a linked list
  *
  * @param item                 current list item
- * @param ...                  user supplied data (only pointers, at most 5)
+ * @param args                 user supplied data
+ * @return                             TRUE, if the item matched, FALSE otherwise
+ */
+typedef bool (*linked_list_match_t)(void *item, va_list args);
+
+/**
+ * Helper function to match a string in a linked list of strings
+ *
+ * @param item                 list item (char*)
+ * @param args                 user supplied data (char*)
  * @return
- *                                             - TRUE, if the item matched
- *                                             - FALSE, otherwise
  */
-typedef bool (*linked_list_match_t)(void *item, ...);
+bool linked_list_match_str(void *item, va_list args);
 
 /**
  * Function to be invoked on elements in a linked list
@@ -167,21 +174,20 @@ struct linked_list_t {
         *
         * The first object passed to the match function is the current list item,
         * followed by the user supplied data.
-        * If the supplied function returns TRUE this function returns SUCCESS, and
-        * the current object is returned in the third parameter, otherwise,
+        * If the supplied function returns TRUE so does this function, and the
+        * current object is returned in the third parameter (if given), otherwise,
         * the next item is checked.
         *
         * If match is NULL, *item and the current object are compared.
         *
-        * @warning Only use pointers as user supplied data.
-        *
         * @param match                 comparison function to call on each object, or NULL
-        * @param item                  the list item, if found
-        * @param ...                   user data to supply to match function (limited to 5 arguments)
-        * @return                              SUCCESS if found, NOT_FOUND otherwise
+        * @param item                  the list item, if found, or NULL
+        * @param ...                   user data to supply to match function
+        * @return                              TRUE if found, FALSE otherwise (or if neither match,
+        *                                              nor item is supplied)
         */
-       status_t (*find_first) (linked_list_t *this, linked_list_match_t match,
-                                                       void **item, ...);
+       bool (*find_first)(linked_list_t *this, linked_list_match_t match,
+                                          void **item, ...);
 
        /**
         * Invoke a method on all of the contained objects.
index 5dd8e42..0a8d3d1 100644 (file)
@@ -812,11 +812,12 @@ static bool verify_trust_chain(private_credential_manager_t *this,
        return trusted;
 }
 
-/**
- * List find match function for certificates
- */
-static bool cert_equals(certificate_t *a, certificate_t *b)
+CALLBACK(cert_equals, bool,
+       certificate_t *a, va_list args)
 {
+       certificate_t *b;
+
+       VA_ARGS_VGET(args, b);
        return a->equals(a, b);
 }
 
@@ -896,8 +897,7 @@ METHOD(enumerator_t, trusted_enumerate, bool,
                        continue;
                }
 
-               if (this->failed->find_first(this->failed, (void*)cert_equals,
-                                                                        NULL, current) == SUCCESS)
+               if (this->failed->find_first(this->failed, cert_equals, NULL, current))
                {       /* check each candidate only once */
                        continue;
                }
index 7576220..4d594e4 100644 (file)
@@ -149,8 +149,12 @@ METHOD(credential_set_t, create_cert_enumerator, enumerator_t*,
                                                                        cert_data_destroy);
 }
 
-static bool certificate_equals(certificate_t *item, certificate_t *cert)
+CALLBACK(certificate_equals, bool,
+       certificate_t *item, va_list args)
 {
+       certificate_t *cert;
+
+       VA_ARGS_VGET(args, cert);
        return item->equals(item, cert);
 }
 
@@ -163,9 +167,8 @@ static certificate_t *add_cert_internal(private_mem_cred_t *this, bool trusted,
 {
        certificate_t *cached;
        this->lock->write_lock(this->lock);
-       if (this->untrusted->find_first(this->untrusted,
-                                                                       (linked_list_match_t)certificate_equals,
-                                                                       (void**)&cached, cert) == SUCCESS)
+       if (this->untrusted->find_first(this->untrusted, certificate_equals,
+                                                                       (void**)&cached, cert))
        {
                cert->destroy(cert);
                cert = cached->get_ref(cached);
@@ -201,9 +204,8 @@ METHOD(mem_cred_t, get_cert_ref, certificate_t*,
        certificate_t *cached;
 
        this->lock->read_lock(this->lock);
-       if (this->untrusted->find_first(this->untrusted,
-                                                                       (linked_list_match_t)certificate_equals,
-                                                                       (void**)&cached, cert) == SUCCESS)
+       if (this->untrusted->find_first(this->untrusted, certificate_equals,
+                                                                       (void**)&cached, cert))
        {
                cert->destroy(cert);
                cert = cached->get_ref(cached);
index 42d795d..096bcbc 100644 (file)
@@ -811,11 +811,12 @@ METHOD(crypto_factory_t, remove_dh, void,
        this->lock->unlock(this->lock);
 }
 
-/**
- * match algorithms of an entry?
- */
-static bool entry_match(entry_t *a, entry_t *b)
+CALLBACK(entry_match, bool,
+       entry_t *a, va_list args)
 {
+       entry_t *b;
+
+       VA_ARGS_VGET(args, b);
        return a->algo == b->algo;
 }
 
@@ -828,7 +829,7 @@ CALLBACK(unique_check, bool,
 
        while (orig->enumerate(orig, &entry))
        {
-               if (list->find_first(list, (void*)entry_match, NULL, entry) == SUCCESS)
+               if (list->find_first(list, entry_match, NULL, entry))
                {
                        continue;
                }
index fcd1195..42d443b 100644 (file)
@@ -606,18 +606,14 @@ static void load_provided(private_plugin_loader_t *this,
                                                  provided_feature_t *provided,
                                                  int level);
 
-/**
- * Used to find a loaded feature
- */
-static bool is_feature_loaded(provided_feature_t *item)
+CALLBACK(is_feature_loaded, bool,
+       provided_feature_t *item, va_list args)
 {
        return item->loaded;
 }
 
-/**
- * Used to find a loadable feature
- */
-static bool is_feature_loadable(provided_feature_t *item)
+CALLBACK(is_feature_loadable, bool,
+       provided_feature_t *item, va_list args)
 {
        return !item->loading && !item->loaded && !item->failed;
 }
@@ -630,8 +626,7 @@ static bool loaded_feature_matches(registered_feature_t *a,
 {
        if (plugin_feature_matches(a->feature, b->feature))
        {
-               return b->plugins->find_first(b->plugins, (void*)is_feature_loaded,
-                                                                         NULL) == SUCCESS;
+               return b->plugins->find_first(b->plugins, is_feature_loaded, NULL);
        }
        return FALSE;
 }
@@ -644,8 +639,7 @@ static bool loadable_feature_equals(registered_feature_t *a,
 {
        if (plugin_feature_equals(a->feature, b->feature))
        {
-               return b->plugins->find_first(b->plugins, (void*)is_feature_loadable,
-                                                                         NULL) == SUCCESS;
+               return b->plugins->find_first(b->plugins, is_feature_loadable, NULL);
        }
        return FALSE;
 }
@@ -658,8 +652,7 @@ static bool loadable_feature_matches(registered_feature_t *a,
 {
        if (plugin_feature_matches(a->feature, b->feature))
        {
-               return b->plugins->find_first(b->plugins, (void*)is_feature_loadable,
-                                                                         NULL) == SUCCESS;
+               return b->plugins->find_first(b->plugins, is_feature_loadable, NULL);
        }
        return FALSE;
 }
@@ -1011,8 +1004,8 @@ static void purge_plugins(private_plugin_loader_t *this)
                {       /* feature interface not supported */
                        continue;
                }
-               if (entry->features->find_first(entry->features,
-                                                                       (void*)is_feature_loaded, NULL) != SUCCESS)
+               if (!entry->features->find_first(entry->features, is_feature_loaded,
+                                                                                NULL))
                {
                        DBG2(DBG_LIB, "unloading plugin '%s' without loaded features",
                                 entry->plugin->get_name(entry->plugin));
@@ -1062,6 +1055,15 @@ static bool find_plugin(char *path, char *name, char *buf, char **file)
        return FALSE;
 }
 
+CALLBACK(find_plugin_cb, bool,
+       char *path, va_list args)
+{
+       char *name, *buf, **file;
+
+       VA_ARGS_VGET(args, name, buf, file);
+       return find_plugin(path, name, buf, file);
+}
+
 /**
  * Used to sort plugins by priority
  */
@@ -1244,8 +1246,8 @@ METHOD(plugin_loader_t, load_plugins, bool,
                }
                if (this->paths)
                {
-                       this->paths->find_first(this->paths, (void*)find_plugin, NULL,
-                                                                       token, buf, &file);
+                       this->paths->find_first(this->paths, find_plugin_cb, NULL, token,
+                                                                       buf, &file);
                }
                if (!file)
                {
index 209e311..aa1e042 100644 (file)
@@ -183,26 +183,48 @@ END_TEST
  * find
  */
 
-static bool match_a_b(void *item, void *a, void *b)
+CALLBACK(find_a_b, bool,
+       void *item, va_list args)
 {
+       void *a, *b;
+
+       VA_ARGS_VGET(args, a, b);
        ck_assert(a == (void*)1);
        ck_assert(b == (void*)2);
        return item == a || item == b;
 }
 
+CALLBACK(find_a, bool,
+       void *item, va_list args)
+{
+       void *a;
+
+       VA_ARGS_VGET(args, a);
+       return match_a(item, a);
+}
+
+CALLBACK(find_b, bool,
+       void *item, va_list args)
+{
+       void *b;
+
+       VA_ARGS_VGET(args, b);
+       return match_b(item, b);
+}
+
 START_TEST(test_find)
 {
        void *a = (void*)1, *b = (void*)2;
 
-       ck_assert(list->find_first(list, NULL, &a) == NOT_FOUND);
+       ck_assert(!list->find_first(list, NULL, &a));
        list->insert_last(list, a);
-       ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
-       ck_assert(list->find_first(list, NULL, &b) == NOT_FOUND);
+       ck_assert(list->find_first(list, NULL, &a));
+       ck_assert(!list->find_first(list, NULL, &b));
        list->insert_last(list, b);
-       ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
-       ck_assert(list->find_first(list, NULL, &b) == SUCCESS);
+       ck_assert(list->find_first(list, NULL, &a));
+       ck_assert(list->find_first(list, NULL, &b));
 
-       ck_assert(list->find_first(list, NULL, NULL) == NOT_FOUND);
+       ck_assert(!list->find_first(list, NULL, NULL));
 }
 END_TEST
 
@@ -210,29 +232,57 @@ START_TEST(test_find_callback)
 {
        void *a = (void*)1, *b = (void*)2, *x = NULL;
 
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == NOT_FOUND);
+       ck_assert(!list->find_first(list, find_a_b, &x, a, b));
        list->insert_last(list, a);
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a, NULL, a) == SUCCESS);
+       ck_assert(list->find_first(list, find_a, NULL, a));
        x = NULL;
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
+       ck_assert(list->find_first(list, find_a, &x, a));
        ck_assert(a == x);
-       ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == NOT_FOUND);
+       ck_assert(!list->find_first(list, find_b, &x, b));
        ck_assert(a == x);
        x = NULL;
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
+       ck_assert(list->find_first(list, find_a_b, &x, a, b));
        ck_assert(a == x);
 
        list->insert_last(list, b);
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
+       ck_assert(list->find_first(list, find_a, &x, a));
        ck_assert(a == x);
-       ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == SUCCESS);
+       ck_assert(list->find_first(list, find_b, &x, b));
        ck_assert(b == x);
        x = NULL;
-       ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
+       ck_assert(list->find_first(list, find_a_b, &x, a, b));
        ck_assert(a == x);
 }
 END_TEST
 
+CALLBACK(find_args, bool,
+       void *item, va_list args)
+{
+       uint64_t d, e;
+       level_t c;
+       int *a, b;
+
+       VA_ARGS_VGET(args, a, b, c, d, e);
+       ck_assert_int_eq(*a, 1);
+       ck_assert_int_eq(b, 2);
+       ck_assert_int_eq(c, LEVEL_PRIVATE);
+       ck_assert_int_eq(d, UINT64_MAX);
+       ck_assert_int_eq(e, UINT64_MAX-1);
+       return item == a;
+}
+
+START_TEST(test_find_callback_args)
+{
+       int a = 1, b = 2, *x;
+       uint64_t d = UINT64_MAX;
+
+       list->insert_last(list, &a);
+       ck_assert(list->find_first(list, find_args, (void**)&x, &a, b,
+                                                          LEVEL_PRIVATE, d, UINT64_MAX-1));
+       ck_assert_int_eq(a, *x);
+}
+END_TEST
+
 /*******************************************************************************
  * invoke
  */
@@ -464,6 +514,7 @@ Suite *linked_list_suite_create()
        tcase_add_checked_fixture(tc, setup_list, teardown_list);
        tcase_add_test(tc, test_find);
        tcase_add_test(tc, test_find_callback);
+       tcase_add_test(tc, test_find_callback_args);
        suite_add_tcase(s, tc);
 
        tc = tcase_create("invoke");