]>
git.proxmox.com Git - mirror_frr.git/blob - fpm/fpm.h
f73ab7c66f2d5749455e221d74cf0888a2ebc92d
2 * Public definitions pertaining to the Forwarding Plane Manager component.
4 * Permission is granted to use, copy, modify and/or distribute this
5 * software under either one of the licenses below.
7 * Note that if you use other files from the Quagga tree directly or
8 * indirectly, then the licenses in those files still apply.
10 * Please retain both licenses below when modifying this code in the
13 * Copyright (C) 2012 by Open Source Routing.
14 * Copyright (C) 2012 by Internet Systems Consortium, Inc. ("ISC")
18 * License Option 1: GPL
20 * This program is free software; you can redistribute it and/or modify it
21 * under the terms of the GNU General Public License as published by the Free
22 * Software Foundation; either version 2 of the License, or (at your option)
25 * This program is distributed in the hope that it will be useful,but WITHOUT
26 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
27 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
36 * License Option 2: ISC License
38 * Permission to use, copy, modify, and/or distribute this software
39 * for any purpose with or without fee is hereby granted, provided
40 * that the above copyright notice and this permission notice appear
43 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
44 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
45 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
46 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
47 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
48 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
49 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
50 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
57 * The Forwarding Plane Manager (FPM) is an optional component that
58 * may be used in scenarios where the router has a forwarding path
59 * that is distinct from the kernel, commonly a hardware-based fast
60 * path. It is responsible for programming forwarding information
61 * (such as routes and nexthops) in the fast path.
63 * In Quagga, the Routing Information Base is maintained in the
64 * 'zebra' infrastructure daemon. Routing protocols communicate their
65 * best routes to zebra, and zebra computes the best route across
66 * protocols for each prefix. This latter information comprises the
67 * bulk of the Forwarding Information Base.
69 * This header file defines a point-to-point interface using which
70 * zebra can update the FPM about changes in routes. The communication
71 * takes place over a stream socket. The FPM listens on a well-known
72 * TCP port, and zebra initiates the connection.
74 * All messages sent over the connection start with a short FPM
75 * header, fpm_msg_hdr_t. In the case of route add/delete messages,
76 * the header is followed by a netlink message. Zebra should send a
77 * complete copy of the forwarding table(s) to the FPM, including
78 * routes that it may have picked up from the kernel.
80 * The FPM interface uses replace semantics. That is, if a 'route add'
81 * message for a prefix is followed by another 'route add' message, the
82 * information in the second message is complete by itself, and replaces
83 * the information sent in the first message.
85 * If the connection to the FPM goes down for some reason, the client
86 * (zebra) should send the FPM a complete copy of the forwarding
87 * table(s) when it reconnects.
91 * Local host as a default server for fpm connection
93 #define FPM_DEFAULT_IP (htonl (INADDR_LOOPBACK))
96 * default port for fpm connections
98 #define FPM_DEFAULT_PORT 2620
101 * Largest message that can be sent to or received from the FPM.
103 #define FPM_MAX_MSG_LEN 4096
110 * Header that precedes each fpm message to/from the FPM.
112 typedef struct fpm_msg_hdr_t_
{
119 * Type of message, see below.
124 * Length of entire message, including the header, in network byte
128 } __attribute__((packed
)) fpm_msg_hdr_t
;
135 * The current version of the FPM protocol is 1.
137 #define FPM_PROTO_VERSION 1
139 typedef enum fpm_msg_type_e_
{
140 FPM_MSG_TYPE_NONE
= 0,
143 * Indicates that the payload is a completely formed netlink
146 * XXX Netlink cares about the alignment of messages. When any
147 * FPM_MSG_TYPE_NETLINK messages are sent over a channel, then all
148 * messages should be sized such that netlink alignment is
151 FPM_MSG_TYPE_NETLINK
= 1,
152 FPM_MSG_TYPE_PROTOBUF
= 2,
156 * The FPM message header is aligned to the same boundary as netlink
157 * messages (4). This means that a netlink message does not need
158 * padding when encapsulated in an FPM message.
160 #define FPM_MSG_ALIGNTO 4
165 * Round up the given length to the desired alignment.
167 * **NB**: Alignment is required only when netlink messages are used.
169 static inline size_t fpm_msg_align(size_t len
)
171 return (len
+ FPM_MSG_ALIGNTO
- 1) & ~(FPM_MSG_ALIGNTO
- 1);
175 * The (rounded up) size of the FPM message header. This ensures that
176 * the message payload always starts at an aligned address.
178 #define FPM_MSG_HDR_LEN (sizeof (fpm_msg_hdr_t))
180 #ifndef COMPILE_ASSERT
181 #define COMPILE_ASSERT(x) extern int __dummy[2 * !!(x) - 1]
184 COMPILE_ASSERT(FPM_MSG_ALIGNTO
== FPM_MSG_HDR_LEN
);
187 * fpm_data_len_to_msg_len
189 * The length value that should be placed in the msg_len field of the
190 * header for a *payload* of size 'data_len'.
192 static inline size_t fpm_data_len_to_msg_len(size_t data_len
)
194 return data_len
+ FPM_MSG_HDR_LEN
;
200 * Pointer to the payload of the given fpm header.
202 static inline void *fpm_msg_data(fpm_msg_hdr_t
*hdr
)
204 return ((char *)hdr
) + FPM_MSG_HDR_LEN
;
210 static inline size_t fpm_msg_len(const fpm_msg_hdr_t
*hdr
)
212 return ntohs(hdr
->msg_len
);
218 static inline size_t fpm_msg_data_len(const fpm_msg_hdr_t
*hdr
)
220 return (fpm_msg_len(hdr
) - FPM_MSG_HDR_LEN
);
226 * Move to the next message in a buffer.
228 static inline fpm_msg_hdr_t
*fpm_msg_next(fpm_msg_hdr_t
*hdr
, size_t *len
)
232 msg_len
= fpm_msg_len(hdr
);
235 if (*len
< msg_len
) {
242 return (fpm_msg_hdr_t
*)(((char *)hdr
) + msg_len
);
248 * Returns true if a message header looks well-formed.
250 static inline int fpm_msg_hdr_ok(const fpm_msg_hdr_t
*hdr
)
254 if (hdr
->msg_type
== FPM_MSG_TYPE_NONE
)
257 msg_len
= fpm_msg_len(hdr
);
259 if (msg_len
< FPM_MSG_HDR_LEN
|| msg_len
> FPM_MAX_MSG_LEN
)
263 * Netlink messages must be aligned properly.
265 if (hdr
->msg_type
== FPM_MSG_TYPE_NETLINK
266 && fpm_msg_align(msg_len
) != msg_len
)
275 * Returns true if a message looks well-formed.
277 * @param len The length in bytes from 'hdr' to the end of the buffer.
279 static inline int fpm_msg_ok(const fpm_msg_hdr_t
*hdr
, size_t len
)
281 if (len
< FPM_MSG_HDR_LEN
)
284 if (!fpm_msg_hdr_ok(hdr
))
287 if (fpm_msg_len(hdr
) > len
)
294 #define TCP_MAX_PORT 65535
297 #define TCP_MIN_PORT 1