]> git.proxmox.com Git - mirror_frr.git/blob - zebra/zebra_fpm_protobuf.c
lib: change comment block to #define to avoid indent.py from breaking comment
[mirror_frr.git] / zebra / zebra_fpm_protobuf.c
1 /*
2 * zebra_fpm_protobuf.c
3 *
4 * @copyright Copyright (C) 2016 Sproute Networks, Inc.
5 *
6 * @author Avneesh Sachdev <avneesh@sproute.com>
7 *
8 * This file is part of Quagga.
9 *
10 * Quagga is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2, or (at your option) any
13 * later version.
14 *
15 * Quagga is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License along
21 * with this program; see the file COPYING; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24 #include <zebra.h>
25
26 #include "log.h"
27 #include "rib.h"
28 #include "zserv.h"
29 #include "zebra_vrf.h"
30
31 #include "qpb/qpb.pb-c.h"
32 #include "qpb/qpb.h"
33 #include "qpb/qpb_allocator.h"
34 #include "qpb/linear_allocator.h"
35 #include "fpm/fpm_pb.h"
36
37 #include "zebra_fpm_private.h"
38
39 /*
40 * create_delete_route_message
41 */
42 static Fpm__DeleteRoute *create_delete_route_message(qpb_allocator_t *allocator,
43 rib_dest_t *dest,
44 struct route_entry *re)
45 {
46 Fpm__DeleteRoute *msg;
47
48 msg = QPB_ALLOC(allocator, typeof(*msg));
49 if (!msg) {
50 assert(0);
51 return NULL;
52 }
53
54 fpm__delete_route__init(msg);
55 msg->vrf_id = zvrf_id(rib_dest_vrf(dest));
56
57 qpb_address_family_set(&msg->address_family, rib_dest_af(dest));
58
59 /*
60 * XXX Hardcode subaddress family for now.
61 */
62 msg->sub_address_family = QPB__SUB_ADDRESS_FAMILY__UNICAST;
63 msg->key = fpm_route_key_create(allocator, rib_dest_prefix(dest));
64 if (!msg->key) {
65 assert(0);
66 return NULL;
67 }
68
69 return msg;
70 }
71
72 /*
73 * add_nexthop
74 */
75 static inline int add_nexthop(qpb_allocator_t *allocator, Fpm__AddRoute *msg,
76 rib_dest_t *dest, struct nexthop *nexthop)
77 {
78 uint32_t if_index;
79 union g_addr *gateway, *src;
80
81 gateway = src = NULL;
82
83 if_index = nexthop->ifindex;
84
85 if (nexthop->type == NEXTHOP_TYPE_IPV4
86 || nexthop->type == NEXTHOP_TYPE_IPV4_IFINDEX) {
87 gateway = &nexthop->gate;
88 if (nexthop->src.ipv4.s_addr)
89 src = &nexthop->src;
90 }
91
92 if (nexthop->type == NEXTHOP_TYPE_IPV6
93 || nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
94 gateway = &nexthop->gate;
95 }
96
97 if (nexthop->type == NEXTHOP_TYPE_IFINDEX) {
98 if (nexthop->src.ipv4.s_addr)
99 src = &nexthop->src;
100 }
101
102 if (!gateway && if_index == 0)
103 return 0;
104
105 /*
106 * We have a valid nexthop.
107 */
108 {
109 Fpm__Nexthop *pb_nh;
110 pb_nh = QPB_ALLOC(allocator, typeof(*pb_nh));
111 if (!pb_nh) {
112 assert(0);
113 return 0;
114 }
115
116 fpm__nexthop__init(pb_nh);
117
118 if (if_index != 0) {
119 pb_nh->if_id =
120 qpb_if_identifier_create(allocator, if_index);
121 }
122
123 if (gateway) {
124 pb_nh->address = qpb_l3_address_create(
125 allocator, gateway, rib_dest_af(dest));
126 }
127
128 msg->nexthops[msg->n_nexthops++] = pb_nh;
129 }
130
131 // TODO: Use src.
132
133 return 1;
134 }
135
136 /*
137 * create_add_route_message
138 */
139 static Fpm__AddRoute *create_add_route_message(qpb_allocator_t *allocator,
140 rib_dest_t *dest,
141 struct route_entry *re)
142 {
143 Fpm__AddRoute *msg;
144 struct nexthop *nexthop;
145 uint num_nhs, u;
146 struct nexthop *nexthops[MULTIPATH_NUM];
147
148 msg = QPB_ALLOC(allocator, typeof(*msg));
149 if (!msg) {
150 assert(0);
151 return NULL;
152 }
153
154 fpm__add_route__init(msg);
155
156 msg->vrf_id = zvrf_id(rib_dest_vrf(dest));
157
158 qpb_address_family_set(&msg->address_family, rib_dest_af(dest));
159
160 /*
161 * XXX Hardcode subaddress family for now.
162 */
163 msg->sub_address_family = QPB__SUB_ADDRESS_FAMILY__UNICAST;
164 msg->key = fpm_route_key_create(allocator, rib_dest_prefix(dest));
165 qpb_protocol_set(&msg->protocol, re->type);
166 msg->route_type = FPM__ROUTE_TYPE__NORMAL;
167 msg->metric = re->metric;
168
169 /*
170 * Figure out the set of nexthops to be added to the message.
171 */
172 num_nhs = 0;
173 for (ALL_NEXTHOPS(re->nexthop, nexthop)) {
174 if (num_nhs >= multipath_num)
175 break;
176
177 if (num_nhs >= ZEBRA_NUM_OF(nexthops))
178 break;
179
180 if (nexthop->type == NEXTHOP_TYPE_BLACKHOLE) {
181 switch (nexthop->bh_type) {
182 case BLACKHOLE_REJECT:
183 msg->route_type = FPM__ROUTE_TYPE__UNREACHABLE;
184 break;
185 case BLACKHOLE_NULL:
186 default:
187 msg->route_type = FPM__ROUTE_TYPE__BLACKHOLE;
188 break;
189 }
190 return msg;
191 }
192
193 if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
194 continue;
195
196 if (!CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_ACTIVE))
197 continue;
198
199 nexthops[num_nhs] = nexthop;
200 num_nhs++;
201 }
202
203 if (!num_nhs) {
204 zfpm_debug("netlink_encode_route(): No useful nexthop.");
205 assert(0);
206 return NULL;
207 }
208
209 /*
210 * And add them to the message.
211 */
212 if (!(msg->nexthops = qpb_alloc_ptr_array(allocator, num_nhs))) {
213 assert(0);
214 return NULL;
215 }
216
217 msg->n_nexthops = 0;
218 for (u = 0; u < num_nhs; u++) {
219 if (!add_nexthop(allocator, msg, dest, nexthops[u])) {
220 assert(0);
221 return NULL;
222 }
223 }
224
225 assert(msg->n_nexthops == num_nhs);
226
227 return msg;
228 }
229
230 /*
231 * create_route_message
232 */
233 static Fpm__Message *create_route_message(qpb_allocator_t *allocator,
234 rib_dest_t *dest,
235 struct route_entry *re)
236 {
237 Fpm__Message *msg;
238
239 msg = QPB_ALLOC(allocator, typeof(*msg));
240 if (!msg) {
241 assert(0);
242 return NULL;
243 }
244
245 fpm__message__init(msg);
246
247 if (!re) {
248 msg->type = FPM__MESSAGE__TYPE__DELETE_ROUTE;
249 msg->delete_route =
250 create_delete_route_message(allocator, dest, re);
251 if (!msg->delete_route) {
252 assert(0);
253 return NULL;
254 }
255 return msg;
256 }
257
258 msg->type = FPM__MESSAGE__TYPE__ADD_ROUTE;
259 msg->add_route = create_add_route_message(allocator, dest, re);
260 if (!msg->add_route) {
261 assert(0);
262 return NULL;
263 }
264
265 return msg;
266 }
267
268 /*
269 * zfpm_protobuf_encode_route
270 *
271 * Create a protobuf message corresponding to the given route in the
272 * given buffer space.
273 *
274 * Returns the number of bytes written to the buffer. 0 or a negative
275 * value indicates an error.
276 */
277 int zfpm_protobuf_encode_route(rib_dest_t *dest, struct route_entry *re,
278 uint8_t *in_buf, size_t in_buf_len)
279 {
280 Fpm__Message *msg;
281 QPB_DECLARE_STACK_ALLOCATOR(allocator, 4096);
282 size_t len;
283
284 QPB_INIT_STACK_ALLOCATOR(allocator);
285
286 msg = create_route_message(&allocator, dest, re);
287 if (!msg) {
288 assert(0);
289 return 0;
290 }
291
292 len = fpm__message__pack(msg, (uint8_t *)in_buf);
293 assert(len <= in_buf_len);
294
295 QPB_RESET_STACK_ALLOCATOR(allocator);
296 return len;
297 }