2 * Label Manager for FRR
4 * Copyright (C) 2017 by Bingen Eguzkitza,
7 * This file is part of FreeRangeRouting (FRR)
9 * FRR is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2, or (at your option) any
14 * FRR is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; see the file COPYING; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26 #include <sys/types.h>
31 #include "lib/memory.h"
33 #include "lib/network.h"
34 #include "lib/stream.h"
35 #include "lib/zclient.h"
37 #include "label_manager.h"
39 #define CONNECTION_DELAY 5
41 struct label_manager lbl_mgr
;
43 DEFINE_MGROUP(LBL_MGR
, "Label Manager");
44 DEFINE_MTYPE_STATIC(LBL_MGR
, LM_CHUNK
, "Label Manager Chunk");
46 /* In case this zebra daemon is not acting as label manager,
47 * it will be a proxy to relay messages to external label manager
48 * This zclient thus is to connect to it
50 static struct zclient
*zclient
;
53 static void delete_label_chunk(void *val
)
55 XFREE(MTYPE_LM_CHUNK
, val
);
58 static int relay_response_back(struct zserv
*zserv
)
61 struct stream
*src
, *dst
;
73 ret
= zclient_read_header(src
, zclient
->sock
, &size
, &marker
, &version
,
75 if (ret
< 0 && errno
!= EAGAIN
) {
76 zlog_err("%s: Error reading Label Manager response: %s",
77 __func__
, strerror(errno
));
80 zlog_debug("%s: Label Manager response received, %d bytes", __func__
,
85 /* send response back */
86 stream_copy(dst
, src
);
87 ret
= writen(zserv
->sock
, dst
->data
, stream_get_endp(dst
));
89 zlog_err("%s: Error sending Label Manager response back: %s",
90 __func__
, strerror(errno
));
93 zlog_debug("%s: Label Manager response (%d bytes) sent back", __func__
,
99 static int lm_zclient_read(struct thread
*t
)
104 /* Get socket to zebra. */
105 zserv
= THREAD_ARG(t
);
106 zclient
->t_read
= NULL
;
108 /* read response and send it back */
109 ret
= relay_response_back(zserv
);
114 static int reply_error(int cmd
, struct zserv
*zserv
, vrf_id_t vrf_id
)
121 zserv_create_header(s
, cmd
, vrf_id
);
126 /* Write packet size. */
127 stream_putw_at(s
, 0, stream_get_endp(s
));
129 return writen(zserv
->sock
, s
->data
, stream_get_endp(s
));
132 * Receive a request to get or release a label chunk and forward it to external
135 * It's called from zserv in case it's not an actual label manager, but just a
138 * @param cmd Type of request (connect, get or release)
140 * @return 0 on success, -1 otherwise
142 int zread_relay_label_manager_request(int cmd
, struct zserv
*zserv
,
145 struct stream
*src
, *dst
;
148 if (zclient
->sock
< 0) {
150 "%s: Error relaying label chunk request: no zclient socket",
152 reply_error(cmd
, zserv
, vrf_id
);
156 /* in case there's any incoming message enqueued, read and forward it */
158 ret
= relay_response_back(zserv
);
160 /* Send request to external label manager */
164 stream_copy(dst
, src
);
166 ret
= writen(zclient
->sock
, dst
->data
, stream_get_endp(dst
));
168 zlog_err("%s: Error relaying label chunk request: %s", __func__
,
170 reply_error(cmd
, zserv
, vrf_id
);
173 zlog_debug("%s: Label chunk request relayed. %d bytes sent", __func__
,
176 /* Release label chunk has no response */
177 if (cmd
== ZEBRA_RELEASE_LABEL_CHUNK
)
180 /* make sure we listen to the response */
181 if (!zclient
->t_read
)
182 thread_add_read(zclient
->master
, lm_zclient_read
, zserv
,
183 zclient
->sock
, &zclient
->t_read
);
188 static int lm_zclient_connect(struct thread
*t
)
190 zclient
->t_connect
= NULL
;
192 if (zclient
->sock
>= 0)
195 if (zclient_socket_connect(zclient
) < 0) {
196 zlog_err("Error connecting synchronous zclient!");
197 thread_add_timer(zebrad
.master
, lm_zclient_connect
, zclient
,
198 CONNECTION_DELAY
, &zclient
->t_connect
);
202 /* make socket non-blocking */
203 if (set_nonblocking(zclient
->sock
) < 0)
204 zlog_warn("%s: set_nonblocking(%d) failed", __func__
,
211 * Function to initialize zclient in case this is not an actual
212 * label manager, but just a proxy to an external one.
214 * @param lm_zserv_path Path to zserv socket of external label manager
216 static void lm_zclient_init(char *lm_zserv_path
)
219 zclient_serv_path_set(lm_zserv_path
);
221 /* Set default values. */
222 zclient
= zclient_new(zebrad
.master
);
224 zclient
->t_connect
= NULL
;
225 lm_zclient_connect(NULL
);
229 * Init label manager (or proxy to an external one)
231 void label_manager_init(char *lm_zserv_path
)
233 /* this is an actual label manager */
234 if (!lm_zserv_path
) {
235 zlog_debug("Initializing own label manager");
236 lm_is_external
= false;
237 lbl_mgr
.lc_list
= list_new();
238 lbl_mgr
.lc_list
->del
= delete_label_chunk
;
239 } else { /* it's acting just as a proxy */
240 zlog_debug("Initializing external label manager at %s",
242 lm_is_external
= true;
243 lm_zclient_init(lm_zserv_path
);
248 * Core function, assigns label cunks
250 * It first searches through the list to check if there's one available
251 * (previously released). Otherwise it creates and assigns a new one
253 * @param proto Daemon protocol of client, to identify the owner
254 * @param instance Instance, to identify the owner
255 * @param keep If set, avoid garbage collection
256 * @para size Size of the label chunk
257 * @return Pointer to the assigned label chunk
259 struct label_manager_chunk
*assign_label_chunk(u_char proto
, u_short instance
,
260 u_char keep
, uint32_t size
)
262 struct label_manager_chunk
*lmc
;
263 struct listnode
*node
;
265 /* first check if there's one available */
266 for (ALL_LIST_ELEMENTS_RO(lbl_mgr
.lc_list
, node
, lmc
)) {
267 if (lmc
->proto
== NO_PROTO
268 && lmc
->end
- lmc
->start
+ 1 == size
) {
270 lmc
->instance
= instance
;
275 /* otherwise create a new one */
276 lmc
= XCALLOC(MTYPE_LM_CHUNK
, sizeof(struct label_manager_chunk
));
280 if (list_isempty(lbl_mgr
.lc_list
))
281 lmc
->start
= MPLS_MIN_UNRESERVED_LABEL
;
283 lmc
->start
= ((struct label_manager_chunk
*)listgetdata(
284 listtail(lbl_mgr
.lc_list
)))
287 if (lmc
->start
> MPLS_MAX_UNRESERVED_LABEL
- size
+ 1) {
288 zlog_err("Reached max labels. Start: %u, size: %u", lmc
->start
,
290 XFREE(MTYPE_LM_CHUNK
, lmc
);
293 lmc
->end
= lmc
->start
+ size
- 1;
295 lmc
->instance
= instance
;
297 listnode_add(lbl_mgr
.lc_list
, lmc
);
303 * Core function, release no longer used label cunks
305 * @param proto Daemon protocol of client, to identify the owner
306 * @param instance Instance, to identify the owner
307 * @param start First label of the chunk
308 * @param end Last label of the chunk
309 * @return 0 on success, -1 otherwise
311 int release_label_chunk(u_char proto
, u_short instance
, uint32_t start
,
314 struct listnode
*node
;
315 struct label_manager_chunk
*lmc
;
318 /* check that size matches */
319 zlog_debug("Releasing label chunk: %u - %u", start
, end
);
320 /* find chunk and disown */
321 for (ALL_LIST_ELEMENTS_RO(lbl_mgr
.lc_list
, node
, lmc
)) {
322 if (lmc
->start
!= start
)
326 if (lmc
->proto
!= proto
|| lmc
->instance
!= instance
) {
327 zlog_err("%s: Daemon mismatch!!", __func__
);
330 lmc
->proto
= NO_PROTO
;
337 zlog_err("%s: Label chunk not released!!", __func__
);
343 * Release label chunks from a client.
345 * Called on client disconnection or reconnection. It only releases chunks
346 * with empty keep value.
348 * @param proto Daemon protocol of client, to identify the owner
349 * @param instance Instance, to identify the owner
350 * @return Number of chunks released
352 int release_daemon_chunks(u_char proto
, u_short instance
)
354 struct listnode
*node
;
355 struct label_manager_chunk
*lmc
;
359 for (ALL_LIST_ELEMENTS_RO(lbl_mgr
.lc_list
, node
, lmc
)) {
360 if (lmc
->proto
== proto
&& lmc
->instance
== instance
362 ret
= release_label_chunk(lmc
->proto
, lmc
->instance
,
363 lmc
->start
, lmc
->end
);
369 zlog_debug("%s: Released %d label chunks", __func__
, count
);
374 void label_manager_close()
376 list_delete(lbl_mgr
.lc_list
);