← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libnl3/trusty

« back to all changes in this revision

Viewing changes to lib/fib_lookup/request.c

  • Committer: Bazaar Package Importer
  • Author(s): Heiko Stuebner
  • Date: 2011-05-21 19:25:13 UTC
  • Revision ID: james.westby@ubuntu.com-20110521192513-1ieyu9w9kym4bt16
Tags: upstream-3.0
Import upstream version 3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/fib_lookup/request.c
 
1
/*
 
2
 * lib/fib_lookup/request.c     FIB Lookup Request
 
3
 *
 
4
 *      This library is free software; you can redistribute it and/or
 
5
 *      modify it under the terms of the GNU Lesser General Public
 
6
 *      License as published by the Free Software Foundation version 2.1
 
7
 *      of the License.
 
8
 *
 
9
 * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
 
10
 */
 
11
 
 
12
/**
 
13
 * @ingroup fib_lookup
 
14
 * @defgroup flreq Request
 
15
 * @brief
 
16
 * @{
 
17
 */
 
18
 
 
19
#include <netlink-local.h>
 
20
#include <netlink/netlink.h>
 
21
#include <netlink/attr.h>
 
22
#include <netlink/utils.h>
 
23
#include <netlink/object.h>
 
24
#include <netlink/fib_lookup/request.h>
 
25
 
 
26
static struct nl_object_ops request_obj_ops;
 
27
 
 
28
/** @cond SKIP */
 
29
#define REQUEST_ATTR_ADDR       0x01
 
30
#define REQUEST_ATTR_FWMARK     0x02
 
31
#define REQUEST_ATTR_TOS        0x04
 
32
#define REQUEST_ATTR_SCOPE      0x08
 
33
#define REQUEST_ATTR_TABLE      0x10
 
34
/** @endcond */
 
35
 
 
36
static void request_free_data(struct nl_object *obj)
 
37
{
 
38
        struct flnl_request *req = REQUEST_CAST(obj);
 
39
 
 
40
        if (req)
 
41
                nl_addr_put(req->lr_addr);
 
42
}
 
43
 
 
44
static int request_clone(struct nl_object *_dst, struct nl_object *_src)
 
45
{
 
46
        struct flnl_request *dst = nl_object_priv(_dst);
 
47
        struct flnl_request *src = nl_object_priv(_src);
 
48
 
 
49
        if (src->lr_addr)
 
50
                if (!(dst->lr_addr = nl_addr_clone(src->lr_addr)))
 
51
                        return -NLE_NOMEM;
 
52
 
 
53
        return 0;
 
54
}
 
55
 
 
56
static int request_compare(struct nl_object *_a, struct nl_object *_b,
 
57
                           uint32_t attrs, int flags)
 
58
{
 
59
        struct flnl_request *a = (struct flnl_request *) _a;
 
60
        struct flnl_request *b = (struct flnl_request *) _b;
 
61
        int diff = 0;
 
62
 
 
63
#define REQ_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, REQUEST_ATTR_##ATTR, a, b, EXPR)
 
64
 
 
65
        diff |= REQ_DIFF(FWMARK,        a->lr_fwmark != b->lr_fwmark);
 
66
        diff |= REQ_DIFF(TOS,           a->lr_tos != b->lr_tos);
 
67
        diff |= REQ_DIFF(SCOPE,         a->lr_scope != b->lr_scope);
 
68
        diff |= REQ_DIFF(TABLE,         a->lr_table != b->lr_table);
 
69
        diff |= REQ_DIFF(ADDR,          nl_addr_cmp(a->lr_addr, b->lr_addr));
 
70
 
 
71
#undef REQ_DIFF
 
72
 
 
73
        return diff;
 
74
}
 
75
 
 
76
 
 
77
/**
 
78
 * @name Lookup Request Creation/Deletion
 
79
 * @{
 
80
 */
 
81
 
 
82
struct flnl_request *flnl_request_alloc(void)
 
83
{
 
84
        return REQUEST_CAST(nl_object_alloc(&request_obj_ops));
 
85
}
 
86
 
 
87
/** @} */
 
88
 
 
89
/**
 
90
 * @name Attributes
 
91
 * @{
 
92
 */
 
93
 
 
94
void flnl_request_set_fwmark(struct flnl_request *req, uint64_t fwmark)
 
95
{
 
96
        req->lr_fwmark = fwmark;
 
97
        req->ce_mask |= REQUEST_ATTR_FWMARK;
 
98
}
 
99
 
 
100
uint64_t flnl_request_get_fwmark(struct flnl_request *req)
 
101
{
 
102
        if (req->ce_mask & REQUEST_ATTR_FWMARK)
 
103
                return req->lr_fwmark;
 
104
        else
 
105
                return UINT_LEAST64_MAX;
 
106
}
 
107
 
 
108
void flnl_request_set_tos(struct flnl_request *req, int tos)
 
109
{
 
110
        req->lr_tos = tos;
 
111
        req->ce_mask |= REQUEST_ATTR_TOS;
 
112
}
 
113
 
 
114
int flnl_request_get_tos(struct flnl_request *req)
 
115
{
 
116
        if (req->ce_mask & REQUEST_ATTR_TOS)
 
117
                return req->lr_tos;
 
118
        else
 
119
                return -1;
 
120
}
 
121
 
 
122
void flnl_request_set_scope(struct flnl_request *req, int scope)
 
123
{
 
124
        req->lr_scope = scope;
 
125
        req->ce_mask |= REQUEST_ATTR_SCOPE;
 
126
}
 
127
 
 
128
int flnl_request_get_scope(struct flnl_request *req)
 
129
{
 
130
        if (req->ce_mask & REQUEST_ATTR_SCOPE)
 
131
                return req->lr_scope;
 
132
        else
 
133
                return -1;
 
134
}
 
135
 
 
136
void flnl_request_set_table(struct flnl_request *req, int table)
 
137
{
 
138
        req->lr_table = table;
 
139
        req->ce_mask |= REQUEST_ATTR_TABLE;
 
140
}
 
141
 
 
142
int flnl_request_get_table(struct flnl_request *req)
 
143
{
 
144
        if (req->ce_mask & REQUEST_ATTR_TABLE)
 
145
                return req->lr_table;
 
146
        else
 
147
                return -1;
 
148
}
 
149
 
 
150
int flnl_request_set_addr(struct flnl_request *req, struct nl_addr *addr)
 
151
{
 
152
        if (addr->a_family != AF_INET)
 
153
                return -NLE_AF_NOSUPPORT;
 
154
 
 
155
        if (req->lr_addr)
 
156
                nl_addr_put(req->lr_addr);
 
157
 
 
158
        nl_addr_get(addr);
 
159
        req->lr_addr = addr;
 
160
 
 
161
        req->ce_mask |= REQUEST_ATTR_ADDR;
 
162
 
 
163
        return 0;
 
164
}
 
165
 
 
166
struct nl_addr *flnl_request_get_addr(struct flnl_request *req)
 
167
{
 
168
        if (req->ce_mask & REQUEST_ATTR_ADDR)
 
169
                return req->lr_addr;
 
170
        else
 
171
                return NULL;
 
172
}
 
173
 
 
174
/** @} */
 
175
 
 
176
static struct nl_object_ops request_obj_ops = {
 
177
        .oo_name                = "fib_lookup/request",
 
178
        .oo_size                = sizeof(struct flnl_request),
 
179
        .oo_free_data           = request_free_data,
 
180
        .oo_clone               = request_clone,
 
181
        .oo_compare             = request_compare,
 
182
        .oo_id_attrs            = ~0,
 
183
};
 
184
 
 
185
/** @} */