2 * Copyright (c) 2012, 2013, JANET(UK)
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of JANET(UK) nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
25 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
27 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
29 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
31 * OF THE POSSIBILITY OF SUCH DAMAGE.
41 #include <tr_filter.h>
42 #include <trp_internal.h>
43 #include <tid_internal.h>
46 /* Function types for handling filter fields generally. All target values
47 * are represented as strings in a TR_NAME.
50 /* CMP functions return values like strcmp: 0 on match, <0 on target<val, >0 on target>val */
51 typedef int (*TR_FILTER_FIELD_CMP)(TR_FILTER_TARGET *target, TR_NAME *val);
52 /* get functions return TR_NAME format of the field value. Caller must free it. */
53 typedef TR_NAME *(*TR_FILTER_FIELD_GET)(TR_FILTER_TARGET *target);
55 static TR_FILTER_TARGET *tr_filter_target_new(TALLOC_CTX *mem_ctx)
57 TR_FILTER_TARGET *target=talloc(mem_ctx, TR_FILTER_TARGET);
59 target->trp_inforec=NULL;
65 void tr_filter_target_free(TR_FILTER_TARGET *target)
71 * Create a filter target for a TID request. Does not change the context of the request,
72 * so this is only valid until that is freed.
74 * @param mem_ctx talloc context for the object
75 * @param req TID request object
76 * @return pointer to a TR_FILTER_TARGET structure, or null on allocation failure
78 TR_FILTER_TARGET *tr_filter_target_tid_req(TALLOC_CTX *mem_ctx, TID_REQ *req)
80 TR_FILTER_TARGET *target=tr_filter_target_new(mem_ctx);
82 target->tid_req=req; /* borrowed, not adding to our context */
87 * Create a filter target for a TRP inforec. Does not change the context of the inforec or duplicate TR_NAMEs,
88 * so this is only valid until those are freed.
90 * @param mem_ctx talloc context for the object
91 * @param upd Update containing the TRP inforec
92 * @param inforec TRP inforec
93 * @return pointer to a TR_FILTER_TARGET structure, or null on allocation failure
95 TR_FILTER_TARGET *tr_filter_target_trp_inforec(TALLOC_CTX *mem_ctx, TRP_UPD *upd, TRP_INFOREC *inforec)
97 TR_FILTER_TARGET *target=tr_filter_target_new(mem_ctx);
99 target->trp_inforec = inforec; /* borrowed, not adding to our context */
105 /** Handler functions for TID RP_REALM field */
106 static int tr_ff_cmp_tid_rp_realm(TR_FILTER_TARGET *target, TR_NAME *val)
108 return tr_name_cmp(tid_req_get_rp_realm(target->tid_req), val);
111 static TR_NAME *tr_ff_get_tid_rp_realm(TR_FILTER_TARGET *target)
113 return tr_dup_name(tid_req_get_rp_realm(target->tid_req));
116 /** Handler functions for TRP info_type field */
117 static int tr_ff_cmp_trp_info_type(TR_FILTER_TARGET *target, TR_NAME *val)
119 TRP_INFOREC *inforec=target->trp_inforec;
126 /* nothing matches unknown */
127 if (inforec->type==TRP_INFOREC_TYPE_UNKNOWN)
130 valstr = tr_name_strdup(val); /* get this as an official null-terminated string */
131 val_type = trp_inforec_type_from_string(valstr);
134 /* we do not define an ordering of info types */
135 return (val_type==inforec->type);
138 static TR_NAME *tr_ff_get_trp_info_type(TR_FILTER_TARGET *target)
140 TRP_INFOREC *inforec=target->trp_inforec;
141 return tr_new_name(trp_inforec_type_to_string(inforec->type));
144 /** Handlers for TRP realm field */
145 static int tr_ff_cmp_trp_realm(TR_FILTER_TARGET *target, TR_NAME *val)
147 return tr_name_cmp(trp_upd_get_realm(target->trp_upd), val);
150 static TR_NAME *tr_ff_get_trp_realm(TR_FILTER_TARGET *target)
152 return tr_dup_name(trp_upd_get_realm(target->trp_upd));
155 /** Handlers for TID realm field */
156 static int tr_ff_cmp_tid_realm(TR_FILTER_TARGET *target, TR_NAME *val)
158 return tr_name_cmp(tid_req_get_realm(target->tid_req), val);
161 static TR_NAME *tr_ff_get_tid_realm(TR_FILTER_TARGET *target)
163 return tr_dup_name(tid_req_get_realm(target->tid_req));
166 /** Handlers for TRP community field */
167 static int tr_ff_cmp_trp_comm(TR_FILTER_TARGET *target, TR_NAME *val)
169 return tr_name_cmp(trp_upd_get_comm(target->trp_upd), val);
172 static TR_NAME *tr_ff_get_trp_comm(TR_FILTER_TARGET *target)
174 return tr_dup_name(trp_upd_get_comm(target->trp_upd));
177 /** Handlers for TID community field */
178 static int tr_ff_cmp_tid_comm(TR_FILTER_TARGET *target, TR_NAME *val)
180 return tr_name_cmp(tid_req_get_comm(target->tid_req), val);
183 static TR_NAME *tr_ff_get_tid_comm(TR_FILTER_TARGET *target)
185 return tr_dup_name(tid_req_get_comm(target->tid_req));
188 /** Handlers for TRP community_type field */
189 static TR_NAME *tr_ff_get_trp_comm_type(TR_FILTER_TARGET *target)
193 switch(trp_inforec_get_comm_type(target->trp_inforec)) {
195 type=tr_new_name("apc");
198 type=tr_new_name("coi");
202 break; /* unknown types always fail */
208 static int tr_ff_cmp_trp_comm_type(TR_FILTER_TARGET *target, TR_NAME *val)
210 TR_NAME *type=tr_ff_get_trp_comm_type(target);
216 retval = tr_name_cmp(val, type);
222 /** Handlers for TRP realm_role field */
223 static TR_NAME *tr_ff_get_trp_realm_role(TR_FILTER_TARGET *target)
227 switch(trp_inforec_get_role(target->trp_inforec)) {
229 type=tr_new_name("idp");
232 type=tr_new_name("rp");
236 break; /* unknown types always fail */
242 static int tr_ff_cmp_trp_realm_role(TR_FILTER_TARGET *target, TR_NAME *val)
244 TR_NAME *type=tr_ff_get_trp_realm_role(target);
250 retval = tr_name_cmp(val, type);
256 /** Handlers for TRP apc field */
257 /* TODO: Handle multiple APCs, not just the first */
258 static int tr_ff_cmp_trp_apc(TR_FILTER_TARGET *target, TR_NAME *val)
260 return tr_name_cmp(tr_apc_get_id(trp_inforec_get_apcs(target->trp_inforec)), val);
263 static TR_NAME *tr_ff_get_trp_apc(TR_FILTER_TARGET *target)
265 TR_APC *apc=trp_inforec_get_apcs(target->trp_inforec);
269 return tr_dup_name(tr_apc_get_id(apc));
272 /** Handlers for TRP owner_realm field */
273 static int tr_ff_cmp_trp_owner_realm(TR_FILTER_TARGET *target, TR_NAME *val)
275 return tr_name_cmp(trp_inforec_get_owner_realm(target->trp_inforec), val);
278 static TR_NAME *tr_ff_get_trp_owner_realm(TR_FILTER_TARGET *target)
280 return tr_dup_name(trp_inforec_get_owner_realm(target->trp_inforec));
283 /** Handlers for TRP trust_router field */
284 static int tr_ff_cmp_trp_trust_router(TR_FILTER_TARGET *target, TR_NAME *val)
286 return tr_name_cmp(trp_inforec_get_trust_router(target->trp_inforec), val);
289 static TR_NAME *tr_ff_get_trp_trust_router(TR_FILTER_TARGET *target)
291 return tr_dup_name(trp_inforec_get_trust_router(target->trp_inforec));
294 /** Handlers for TRP owner_contact field */
295 static int tr_ff_cmp_trp_owner_contact(TR_FILTER_TARGET *target, TR_NAME *val)
297 return tr_name_cmp(trp_inforec_get_owner_contact(target->trp_inforec), val);
300 static TR_NAME *tr_ff_get_trp_owner_contact(TR_FILTER_TARGET *target)
302 return tr_dup_name(trp_inforec_get_owner_contact(target->trp_inforec));
305 /** Handlers for TID req original_coi field */
306 static int tr_ff_cmp_tid_orig_coi(TR_FILTER_TARGET *target, TR_NAME *val)
308 return tr_name_cmp(tid_req_get_orig_coi(target->tid_req), val);
311 static TR_NAME *tr_ff_get_tid_orig_coi(TR_FILTER_TARGET *target)
313 return tr_dup_name(tid_req_get_orig_coi(target->tid_req));
317 * Filter field handler table
319 struct tr_filter_field_entry {
320 TR_FILTER_TYPE filter_type;
322 TR_FILTER_FIELD_CMP cmp;
323 TR_FILTER_FIELD_GET get;
325 static struct tr_filter_field_entry tr_filter_field_table[] = {
327 {TR_FILTER_TYPE_TID_INBOUND, "realm", tr_ff_cmp_tid_realm, tr_ff_get_tid_realm},
328 {TR_FILTER_TYPE_TRP_INBOUND, "realm", tr_ff_cmp_trp_realm, tr_ff_get_trp_realm},
329 {TR_FILTER_TYPE_TRP_OUTBOUND, "realm", tr_ff_cmp_trp_realm, tr_ff_get_trp_realm},
332 {TR_FILTER_TYPE_TID_INBOUND, "comm", tr_ff_cmp_tid_comm, tr_ff_get_tid_comm},
333 {TR_FILTER_TYPE_TRP_INBOUND, "comm", tr_ff_cmp_trp_comm, tr_ff_get_trp_comm},
334 {TR_FILTER_TYPE_TRP_OUTBOUND, "comm", tr_ff_cmp_trp_comm, tr_ff_get_trp_comm},
337 {TR_FILTER_TYPE_TRP_INBOUND, "comm_type", tr_ff_cmp_trp_comm_type, tr_ff_get_trp_comm_type},
338 {TR_FILTER_TYPE_TRP_OUTBOUND, "comm_type", tr_ff_cmp_trp_comm_type, tr_ff_get_trp_comm_type},
341 {TR_FILTER_TYPE_TRP_INBOUND, "realm_role", tr_ff_cmp_trp_realm_role, tr_ff_get_trp_realm_role},
342 {TR_FILTER_TYPE_TRP_OUTBOUND, "realm_role", tr_ff_cmp_trp_realm_role, tr_ff_get_trp_realm_role},
345 {TR_FILTER_TYPE_TRP_INBOUND, "apc", tr_ff_cmp_trp_apc, tr_ff_get_trp_apc},
346 {TR_FILTER_TYPE_TRP_OUTBOUND, "apc", tr_ff_cmp_trp_apc, tr_ff_get_trp_apc},
349 {TR_FILTER_TYPE_TRP_INBOUND, "trust_router", tr_ff_cmp_trp_trust_router, tr_ff_get_trp_trust_router},
350 {TR_FILTER_TYPE_TRP_OUTBOUND, "trust_router", tr_ff_cmp_trp_trust_router, tr_ff_get_trp_trust_router},
353 {TR_FILTER_TYPE_TRP_INBOUND, "owner_realm", tr_ff_cmp_trp_owner_realm, tr_ff_get_trp_owner_realm},
354 {TR_FILTER_TYPE_TRP_OUTBOUND, "owner_realm", tr_ff_cmp_trp_owner_realm, tr_ff_get_trp_owner_realm},
357 {TR_FILTER_TYPE_TRP_INBOUND, "owner_contact", tr_ff_cmp_trp_owner_contact, tr_ff_get_trp_owner_contact},
358 {TR_FILTER_TYPE_TRP_OUTBOUND, "owner_contact", tr_ff_cmp_trp_owner_contact, tr_ff_get_trp_owner_contact},
361 {TR_FILTER_TYPE_TID_INBOUND, "rp_realm", tr_ff_cmp_tid_rp_realm, tr_ff_get_tid_rp_realm},
364 {TR_FILTER_TYPE_TID_INBOUND, "original_coi", tr_ff_cmp_tid_orig_coi, tr_ff_get_tid_orig_coi},
367 {TR_FILTER_TYPE_TRP_INBOUND, "info_type", tr_ff_cmp_trp_info_type, tr_ff_get_trp_info_type},
368 {TR_FILTER_TYPE_TRP_OUTBOUND, "info_type", tr_ff_cmp_trp_info_type, tr_ff_get_trp_info_type},
371 {TR_FILTER_TYPE_UNKNOWN, NULL } /* This must be the final entry */
374 /* TODO: support TRP metric field (requires > < comparison instead of wildcard match) */
376 static struct tr_filter_field_entry *tr_filter_field_entry(TR_FILTER_TYPE filter_type, TR_NAME *field_name)
380 for (ii=0; tr_filter_field_table[ii].filter_type!=TR_FILTER_TYPE_UNKNOWN; ii++) {
381 if ((tr_filter_field_table[ii].filter_type==filter_type)
382 && (tr_name_cmp_str(field_name, tr_filter_field_table[ii].name)==0)) {
383 return tr_filter_field_table+ii;
390 * Apply a filter to a target record or TID request.
392 * If one of the filter lines matches, out_action is set to the applicable action. If constraints
393 * is not NULL, the constraints from the matching filter line will be added to the constraint set
394 * *constraints, or to a new one if *constraints is NULL. In this case, TR_FILTER_MATCH will be
397 * If there is no match, returns TR_FILTER_NO_MATCH, out_action is undefined, and constraints
398 * will not be changed.
400 * @param target Record or request to which the filter is applied
401 * @param filt Filter to apply
402 * @param constraints Pointer to existing set of constraints (NULL if not tracking constraints)
403 * @param out_action Action to be carried out (output)
404 * @return TR_FILTER_MATCH or TR_FILTER_NO_MATCH
406 int tr_filter_apply(TR_FILTER_TARGET *target,
408 TR_CONSTRAINT_SET **constraints,
409 TR_FILTER_ACTION *out_action)
411 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
412 TR_FILTER_ITER *filt_iter = tr_filter_iter_new(tmp_ctx);
413 TR_FLINE *this_fline = NULL;
414 TR_FLINE_ITER *fline_iter = tr_fline_iter_new(tmp_ctx);
415 TR_FSPEC *this_fspec = NULL;
416 int retval=TR_FILTER_NO_MATCH;
418 /* Default action is reject */
419 *out_action = TR_FILTER_ACTION_REJECT;
421 /* Validate filter */
422 if ((filt_iter == NULL) || (fline_iter == NULL) || (filt==NULL) || (filt->type==TR_FILTER_TYPE_UNKNOWN)) {
423 talloc_free(tmp_ctx);
424 return TR_FILTER_NO_MATCH;
427 /* Step through filter lines looking for a match. If a line matches, retval
428 * will be set to TR_FILTER_MATCH, so stop then. */
429 this_fline = tr_filter_iter_first(filt_iter, filt);
431 /* Assume we are going to succeed. If any specs fail to match, we'll set
432 * this to TR_FILTER_NO_MATCH. */
433 retval=TR_FILTER_MATCH;
434 this_fspec = tr_fline_iter_first(fline_iter, this_fline);
436 if (!tr_fspec_matches(this_fspec, filt->type, target)) {
437 retval=TR_FILTER_NO_MATCH; /* set this in case this is the last filter line */
438 break; /* give up on this filter line */
440 this_fspec = tr_fline_iter_next(fline_iter);
443 if (retval==TR_FILTER_MATCH)
446 this_fline = tr_filter_iter_next(filt_iter);
449 if (retval==TR_FILTER_MATCH) {
450 /* Matched line ii. Grab its action and constraints. */
451 *out_action = this_fline->action;
452 if (constraints!=NULL) {
453 /* if either constraint is missing, these are no-ops */
454 tr_constraint_add_to_set(constraints, this_fline->realm_cons);
455 tr_constraint_add_to_set(constraints, this_fline->domain_cons);
462 void tr_fspec_free(TR_FSPEC *fspec)
468 * Helper for tr_fspec_destructor - calls tr_free_name on its first argument
470 * @param item void pointer to a TR_NAME
471 * @param cookie ignored
473 static void fspec_destruct_helper(void *item, void *cookie)
475 TR_NAME *name = (TR_NAME *) item;
478 static int tr_fspec_destructor(void *obj)
480 TR_FSPEC *fspec = talloc_get_type_abort(obj, TR_FSPEC);
482 if (fspec->field != NULL)
483 tr_free_name(fspec->field);
486 tr_list_foreach(fspec->match, fspec_destruct_helper, NULL);
491 TR_FSPEC *tr_fspec_new(TALLOC_CTX *mem_ctx)
493 TR_FSPEC *fspec = talloc(mem_ctx, TR_FSPEC);
497 fspec->match = tr_list_new(fspec);
498 if (fspec->match == NULL) {
502 talloc_set_destructor((void *)fspec, tr_fspec_destructor);
507 /* Helper function and cookie structure for finding a match. The helper is called
508 * for every item in the match list, even after a match is found. If a match is found,
509 * match should be pointed to the matching item. If this is not NULL, do not change it
510 * because a match has already been found. */
511 struct fspec_match_cookie { TR_NAME *name; TR_NAME *match;};
512 static void fspec_match_helper(void *item, void *data)
514 TR_NAME *this_name = (TR_NAME *) item;
515 struct fspec_match_cookie *cookie = (struct fspec_match_cookie *) data;
516 if (cookie->match == NULL) {
517 if (tr_name_prefix_wildcard_match(cookie->name, this_name))
518 cookie->match = this_name;
521 /* returns 1 if the spec matches */
522 int tr_fspec_matches(TR_FSPEC *fspec, TR_FILTER_TYPE ftype, TR_FILTER_TARGET *target)
524 struct tr_filter_field_entry *field=NULL;
525 struct fspec_match_cookie cookie = {0};
530 /* Look up how to handle the requested field */
531 field = tr_filter_field_entry(ftype, fspec->field);
533 tr_err("tr_fspec_matches: No entry to handle field %.*s for %*s filter.",
534 fspec->field->len, fspec->field->buf,
535 tr_filter_type_to_string(ftype));
539 cookie.name = field->get(target);
540 if (cookie.name==NULL)
541 return 0; /* if there's no value, there's no match */
544 tr_list_foreach(fspec->match,
548 tr_debug("tr_fspec_matches: Field %.*s value \"%.*s\" matches \"%.*s\" for %s filter.",
549 fspec->field->len, fspec->field->buf,
550 cookie.name->len, cookie.name->buf,
551 cookie.match->len, cookie.match->buf,
552 tr_filter_type_to_string(ftype));
554 tr_debug("tr_fspec_matches: Field %.*s value \"%.*s\" does not match for %s filter.",
555 fspec->field->len, fspec->field->buf,
556 cookie.name->len, cookie.name->buf,
557 tr_filter_type_to_string(ftype));
559 return (cookie.match != NULL);
562 void tr_fline_free(TR_FLINE *fline)
567 TR_FLINE *tr_fline_new(TALLOC_CTX *mem_ctx)
569 TR_FLINE *fl = talloc(mem_ctx, TR_FLINE);
572 fl->action = TR_FILTER_ACTION_UNKNOWN;
573 fl->realm_cons = NULL;
574 fl->domain_cons = NULL;
575 fl->specs = tr_list_new(fl);
576 if (fl->specs == NULL) {
584 TR_FILTER *tr_filter_new(TALLOC_CTX *mem_ctx)
586 TR_FILTER *f = talloc(mem_ctx, TR_FILTER);
589 f->type = TR_FILTER_TYPE_UNKNOWN;
590 f->lines = tr_list_new(f);
591 if (f->lines == NULL) {
599 void tr_filter_free(TR_FILTER *filt)
604 void tr_filter_set_type(TR_FILTER *filt, TR_FILTER_TYPE type)
609 TR_FILTER_TYPE tr_filter_get_type(TR_FILTER *filt)
615 * Check that a filter is valid, i.e., can be processed.
617 * @param filt Filter to verify
618 * @return 1 if the filter is valid, 0 otherwise
620 int tr_filter_validate(TR_FILTER *filt)
622 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
623 TR_FILTER_ITER *filt_iter = tr_filter_iter_new(tmp_ctx);
624 TR_FLINE *this_fline = NULL;
625 TR_FLINE_ITER *fline_iter = tr_fline_iter_new(tmp_ctx);
626 TR_FSPEC *this_fspec = NULL;
628 if ((!filt) || (!filt_iter) || (!fline_iter)) {
629 talloc_free(tmp_ctx);
633 /* check that we recognize the type */
635 case TR_FILTER_TYPE_TID_INBOUND:
636 case TR_FILTER_TYPE_TRP_INBOUND:
637 case TR_FILTER_TYPE_TRP_OUTBOUND:
641 talloc_free(tmp_ctx);
642 return 0; /* if we get here, either TR_FILTER_TYPE_UNKNOWN or an invalid value was found */
645 this_fline = tr_filter_iter_first(filt_iter, filt);
647 /* check that we recognize the action */
648 switch(this_fline->action) {
649 case TR_FILTER_ACTION_ACCEPT:
650 case TR_FILTER_ACTION_REJECT:
654 /* if we get here, either TR_FILTER_ACTION_UNKNOWN or an invalid value was found */
655 talloc_free(tmp_ctx);
659 this_fspec = tr_fline_iter_first(fline_iter, this_fline);
661 if (!tr_filter_validate_spec_field(filt->type, this_fspec)) {
662 talloc_free(tmp_ctx);
666 /* check that at least one match is defined*/
667 if (tr_list_length(this_fspec->match) == 0) {
668 talloc_free(tmp_ctx);
671 this_fspec = tr_fline_iter_next(fline_iter);
673 this_fline = tr_filter_iter_next(filt_iter);
676 /* We ran the gauntlet. Success! */
677 talloc_free(tmp_ctx);
681 int tr_filter_validate_spec_field(TR_FILTER_TYPE ftype, TR_FSPEC *fspec)
683 if ((fspec==NULL) || (tr_filter_field_entry(ftype, fspec->field)==NULL))
684 return 0; /* unknown field */
690 * Allocate a new filter set.
692 * @param mem_ctx Talloc context for the new set
693 * @return Pointer to new set, or null on error
695 TR_FILTER_SET *tr_filter_set_new(TALLOC_CTX *mem_ctx)
697 TR_FILTER_SET *set=talloc(mem_ctx, TR_FILTER_SET);
708 * @param fs Filter set to free
710 void tr_filter_set_free(TR_FILTER_SET *fs)
716 * Find the tail of the filter set linked list.
718 * @param set Set to find tail of
719 * @return Last element in the list
721 static TR_FILTER_SET *tr_filter_set_tail(TR_FILTER_SET *set)
729 * Add new filter to filter set.
731 * @param set Filter set
732 * @param new New filter to add
733 * @return 0 on success, nonzero on error
735 int tr_filter_set_add(TR_FILTER_SET *set, TR_FILTER *new)
737 TR_FILTER_SET *tail=NULL;
742 tail=tr_filter_set_tail(set);
743 tail->next=tr_filter_set_new(set);
744 if (tail->next==NULL)
749 talloc_steal(tail, new);
754 * Find a filter of a given type in the filter set. If there are multiple, returns the first one.
756 * @param set Filter set to search
757 * @param type Type of filter to find
758 * @return Borrowed pointer to the filter, or null if no filter of that type is found
760 TR_FILTER *tr_filter_set_get(TR_FILTER_SET *set, TR_FILTER_TYPE type)
762 TR_FILTER_SET *cur=set;
764 if ((cur->this != NULL) && (cur->this->type == type))
771 TR_FILTER_TYPE filter_type[]={TR_FILTER_TYPE_TID_INBOUND,
772 TR_FILTER_TYPE_TRP_INBOUND,
773 TR_FILTER_TYPE_TRP_OUTBOUND};
774 const char *filter_label[]={"tid_inbound",
777 size_t num_filter_types=sizeof(filter_type)/sizeof(filter_type[0]);
779 const char *tr_filter_type_to_string(TR_FILTER_TYPE ftype)
783 for (ii=0; ii<num_filter_types; ii++) {
784 if (ftype==filter_type[ii])
785 return filter_label[ii];
790 TR_FILTER_TYPE tr_filter_type_from_string(const char *s)
794 for(ii=0; ii<num_filter_types; ii++) {
795 if (0==strcmp(s, filter_label[ii]))
796 return filter_type[ii];
798 return TR_FILTER_TYPE_UNKNOWN;