Annotation of embedaddon/quagga/fpm/fpm.h, revision 1.1
1.1 ! misho 1: /*
! 2: * Public definitions pertaining to the Forwarding Plane Manager component.
! 3: *
! 4: * Permission is granted to use, copy, modify and/or distribute this
! 5: * software under either one of the licenses below.
! 6: *
! 7: * Note that if you use other files from the Quagga tree directly or
! 8: * indirectly, then the licenses in those files still apply.
! 9: *
! 10: * Please retain both licenses below when modifying this code in the
! 11: * Quagga tree.
! 12: *
! 13: * Copyright (C) 2012 by Open Source Routing.
! 14: * Copyright (C) 2012 by Internet Systems Consortium, Inc. ("ISC")
! 15: */
! 16:
! 17: /*
! 18: * License Option 1: GPL
! 19: *
! 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)
! 23: * any later version.
! 24: *
! 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
! 28: * more details.
! 29: *
! 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.
! 33: */
! 34:
! 35: /*
! 36: * License Option 2: ISC License
! 37: *
! 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
! 41: * in all copies.
! 42: *
! 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.
! 51: */
! 52:
! 53: #ifndef _FPM_H
! 54: #define _FPM_H
! 55:
! 56: /*
! 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.
! 62: *
! 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.
! 68: *
! 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.
! 73: *
! 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.
! 79: *
! 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.
! 84: *
! 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.
! 88: */
! 89:
! 90: #define FPM_DEFAULT_PORT 2620
! 91:
! 92: /*
! 93: * Largest message that can be sent to or received from the FPM.
! 94: */
! 95: #define FPM_MAX_MSG_LEN 4096
! 96:
! 97: /*
! 98: * Header that precedes each fpm message to/from the FPM.
! 99: */
! 100: typedef struct fpm_msg_hdr_t_
! 101: {
! 102: /*
! 103: * Protocol version.
! 104: */
! 105: uint8_t version;
! 106:
! 107: /*
! 108: * Type of message, see below.
! 109: */
! 110: uint8_t msg_type;
! 111:
! 112: /*
! 113: * Length of entire message, including the header, in network byte
! 114: * order.
! 115: *
! 116: * Note that msg_len is rounded up to make sure that message is at
! 117: * the desired alignment. This means that some payloads may need
! 118: * padding at the end.
! 119: */
! 120: uint16_t msg_len;
! 121: } fpm_msg_hdr_t;
! 122:
! 123: /*
! 124: * The current version of the FPM protocol is 1.
! 125: */
! 126: #define FPM_PROTO_VERSION 1
! 127:
! 128: typedef enum fpm_msg_type_e_ {
! 129: FPM_MSG_TYPE_NONE = 0,
! 130:
! 131: /*
! 132: * Indicates that the payload is a completely formed netlink
! 133: * message.
! 134: */
! 135: FPM_MSG_TYPE_NETLINK = 1,
! 136: } fpm_msg_type_e;
! 137:
! 138: /*
! 139: * The FPM message header is aligned to the same boundary as netlink
! 140: * messages (4). This means that a netlink message does not need
! 141: * padding when encapsulated in an FPM message.
! 142: */
! 143: #define FPM_MSG_ALIGNTO 4
! 144:
! 145: /*
! 146: * fpm_msg_align
! 147: *
! 148: * Round up the given length to the desired alignment.
! 149: */
! 150: static inline size_t
! 151: fpm_msg_align (size_t len)
! 152: {
! 153: return (len + FPM_MSG_ALIGNTO - 1) & ~(FPM_MSG_ALIGNTO - 1);
! 154: }
! 155:
! 156: /*
! 157: * The (rounded up) size of the FPM message header. This ensures that
! 158: * the message payload always starts at an aligned address.
! 159: */
! 160: #define FPM_MSG_HDR_LEN (fpm_msg_align (sizeof (fpm_msg_hdr_t)))
! 161:
! 162: /*
! 163: * fpm_data_len_to_msg_len
! 164: *
! 165: * The length value that should be placed in the msg_len field of the
! 166: * header for a *payload* of size 'data_len'.
! 167: */
! 168: static inline size_t
! 169: fpm_data_len_to_msg_len (size_t data_len)
! 170: {
! 171: return fpm_msg_align (data_len) + FPM_MSG_HDR_LEN;
! 172: }
! 173:
! 174: /*
! 175: * fpm_msg_data
! 176: *
! 177: * Pointer to the payload of the given fpm header.
! 178: */
! 179: static inline void *
! 180: fpm_msg_data (fpm_msg_hdr_t *hdr)
! 181: {
! 182: return ((char*) hdr) + FPM_MSG_HDR_LEN;
! 183: }
! 184:
! 185: /*
! 186: * fpm_msg_len
! 187: */
! 188: static inline size_t
! 189: fpm_msg_len (const fpm_msg_hdr_t *hdr)
! 190: {
! 191: return ntohs (hdr->msg_len);
! 192: }
! 193:
! 194: /*
! 195: * fpm_msg_data_len
! 196: */
! 197: static inline size_t
! 198: fpm_msg_data_len (const fpm_msg_hdr_t *hdr)
! 199: {
! 200: return (fpm_msg_len (hdr) - FPM_MSG_HDR_LEN);
! 201: }
! 202:
! 203: /*
! 204: * fpm_msg_next
! 205: *
! 206: * Move to the next message in a buffer.
! 207: */
! 208: static inline fpm_msg_hdr_t *
! 209: fpm_msg_next (fpm_msg_hdr_t *hdr, size_t *len)
! 210: {
! 211: size_t msg_len;
! 212:
! 213: msg_len = fpm_msg_len (hdr);
! 214:
! 215: if (len) {
! 216: if (*len < msg_len)
! 217: {
! 218: assert(0);
! 219: return NULL;
! 220: }
! 221: *len -= msg_len;
! 222: }
! 223:
! 224: return (fpm_msg_hdr_t *) (((char*) hdr) + msg_len);
! 225: }
! 226:
! 227: /*
! 228: * fpm_msg_hdr_ok
! 229: *
! 230: * Returns TRUE if a message header looks well-formed.
! 231: */
! 232: static inline int
! 233: fpm_msg_hdr_ok (const fpm_msg_hdr_t *hdr)
! 234: {
! 235: size_t msg_len;
! 236:
! 237: if (hdr->msg_type == FPM_MSG_TYPE_NONE)
! 238: return 0;
! 239:
! 240: msg_len = fpm_msg_len (hdr);
! 241:
! 242: if (msg_len < FPM_MSG_HDR_LEN || msg_len > FPM_MAX_MSG_LEN)
! 243: return 0;
! 244:
! 245: if (fpm_msg_align (msg_len) != msg_len)
! 246: return 0;
! 247:
! 248: return 1;
! 249: }
! 250:
! 251: /*
! 252: * fpm_msg_ok
! 253: *
! 254: * Returns TRUE if a message looks well-formed.
! 255: *
! 256: * @param len The length in bytes from 'hdr' to the end of the buffer.
! 257: */
! 258: static inline int
! 259: fpm_msg_ok (const fpm_msg_hdr_t *hdr, size_t len)
! 260: {
! 261: if (len < FPM_MSG_HDR_LEN)
! 262: return 0;
! 263:
! 264: if (!fpm_msg_hdr_ok (hdr))
! 265: return 0;
! 266:
! 267: if (fpm_msg_len (hdr) > len)
! 268: return 0;
! 269:
! 270: return 1;
! 271: }
! 272:
! 273: #endif /* _FPM_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to fpm.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / fpm