fpm/fpm.h

   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 /*
  91  * Local host as a default server for fpm connection
  92  */
  93 #define FPM_DEFAULT_IP              (htonl (INADDR_LOOPBACK))
  94
  95 /*
  96  * default port for fpm connections
  97  */
  98 #define FPM_DEFAULT_PORT 2620
  99
 100 /*
 101  * Largest message that can be sent to or received from the FPM.
 102  */
 103 #define FPM_MAX_MSG_LEN 4096
 104
 105 #ifdef __SUNPRO_C
 106 #pragma pack(1)
 107 #endif
 108
 109 /*
 110  * Header that precedes each fpm message to/from the FPM.
 111  */
 112 typedef struct fpm_msg_hdr_t_
 113 {
 114   /*
 115    * Protocol version.
 116    */
 117   uint8_t version;
 118
 119   /*
 120    * Type of message, see below.
 121    */
 122   uint8_t msg_type;
 123
 124   /*
 125    * Length of entire message, including the header, in network byte
 126    * order.
 127    */
 128   uint16_t msg_len;
 129 } __attribute__ ((packed)) fpm_msg_hdr_t;
 130
 131 #ifdef __SUNPRO_C
 132 #pragma pack()
 133 #endif
 134
 135 /*
 136  * The current version of the FPM protocol is 1.
 137  */
 138 #define FPM_PROTO_VERSION 1
 139
 140 typedef enum fpm_msg_type_e_ {
 141   FPM_MSG_TYPE_NONE = 0,
 142
 143   /*
 144    * Indicates that the payload is a completely formed netlink
 145    * message.
 146    *
 147    * XXX Netlink cares about the alignment of messages. When any
 148    * FPM_MSG_TYPE_NETLINK messages are sent over a channel, then all
 149    * messages should be sized such that netlink alignment is
 150    * maintained.
 151    */
 152   FPM_MSG_TYPE_NETLINK = 1,
 153   FPM_MSG_TYPE_PROTOBUF = 2,
 154 } fpm_msg_type_e;
 155
 156 /*
 157  * The FPM message header is aligned to the same boundary as netlink
 158  * messages (4). This means that a netlink message does not need
 159  * padding when encapsulated in an FPM message.
 160  */
 161 #define FPM_MSG_ALIGNTO 4
 162
 163 /*
 164  * fpm_msg_align
 165  *
 166  * Round up the given length to the desired alignment.
 167  *
 168  * **NB**: Alignment is required only when netlink messages are used.
 169  */
 170 static inline size_t
 171 fpm_msg_align (size_t len)
 172 {
 173   return (len + FPM_MSG_ALIGNTO - 1) & ~(FPM_MSG_ALIGNTO - 1);
 174 }
 175
 176 /*
 177  * The (rounded up) size of the FPM message header. This ensures that
 178  * the message payload always starts at an aligned address.
 179  */
 180 #define FPM_MSG_HDR_LEN (sizeof (fpm_msg_hdr_t))
 181
 182 #ifndef COMPILE_ASSERT
 183 #define COMPILE_ASSERT(x) extern int __dummy[2 * !!(x) - 1]
 184 #endif
 185
 186 COMPILE_ASSERT(FPM_MSG_ALIGNTO == FPM_MSG_HDR_LEN);
 187
 188 /*
 189  * fpm_data_len_to_msg_len
 190  *
 191  * The length value that should be placed in the msg_len field of the
 192  * header for a *payload* of size 'data_len'.
 193  */
 194 static inline size_t
 195 fpm_data_len_to_msg_len (size_t data_len)
 196 {
 197   return data_len + FPM_MSG_HDR_LEN;
 198 }
 199
 200 /*
 201  * fpm_msg_data
 202  *
 203  * Pointer to the payload of the given fpm header.
 204  */
 205 static inline void *
 206 fpm_msg_data (fpm_msg_hdr_t *hdr)
 207 {
 208   return ((char*) hdr) + FPM_MSG_HDR_LEN;
 209 }
 210
 211 /*
 212  * fpm_msg_len
 213  */
 214 static inline size_t
 215 fpm_msg_len (const fpm_msg_hdr_t *hdr)
 216 {
 217   return ntohs (hdr->msg_len);
 218 }
 219
 220 /*
 221  * fpm_msg_data_len
 222  */
 223 static inline size_t
 224 fpm_msg_data_len (const fpm_msg_hdr_t *hdr)
 225 {
 226   return (fpm_msg_len (hdr) - FPM_MSG_HDR_LEN);
 227 }
 228
 229 /*
 230  * fpm_msg_next
 231  *
 232  * Move to the next message in a buffer.
 233  */
 234 static inline fpm_msg_hdr_t *
 235 fpm_msg_next (fpm_msg_hdr_t *hdr, size_t *len)
 236 {
 237   size_t msg_len;
 238
 239   msg_len = fpm_msg_len (hdr);
 240
 241   if (len) {
 242     if (*len < msg_len)
 243       {
 244         assert(0);
 245         return NULL;
 246       }
 247     *len -= msg_len;
 248   }
 249
 250   return (fpm_msg_hdr_t *) (((char*) hdr) + msg_len);
 251 }
 252
 253 /*
 254  * fpm_msg_hdr_ok
 255  *
 256  * Returns TRUE if a message header looks well-formed.
 257  */
 258 static inline int
 259 fpm_msg_hdr_ok (const fpm_msg_hdr_t *hdr)
 260 {
 261   size_t msg_len;
 262
 263   if (hdr->msg_type == FPM_MSG_TYPE_NONE)
 264     return 0;
 265
 266   msg_len = fpm_msg_len (hdr);
 267
 268   if (msg_len < FPM_MSG_HDR_LEN || msg_len > FPM_MAX_MSG_LEN)
 269     return 0;
 270
 271   /*
 272    * Netlink messages must be aligned properly.
 273    */
 274   if (hdr->msg_type == FPM_MSG_TYPE_NETLINK &&
 275       fpm_msg_align (msg_len) != msg_len)
 276     return 0;
 277
 278   return 1;
 279 }
 280
 281 /*
 282  * fpm_msg_ok
 283  *
 284  * Returns TRUE if a message looks well-formed.
 285  *
 286  * @param len The length in bytes from 'hdr' to the end of the buffer.
 287  */
 288 static inline int
 289 fpm_msg_ok (const fpm_msg_hdr_t *hdr, size_t len)
 290 {
 291   if (len < FPM_MSG_HDR_LEN)
 292     return 0;
 293
 294   if (!fpm_msg_hdr_ok (hdr))
 295     return 0;
 296
 297   if (fpm_msg_len (hdr) > len)
 298     return 0;
 299
 300   return 1;
 301 }
 302
 303 // tcp maximum range
 304 #define TCP_MAX_PORT   65535
 305
 306 // tcp minimum range
 307 #define TCP_MIN_PORT   1
 308
 309 #endif /* _FPM_H */