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 /*
 106  * Header that precedes each fpm message to/from the FPM.
 107  */
 108 typedef struct fpm_msg_hdr_t_
 109 {
 110   /*
 111    * Protocol version.
 112    */
 113   uint8_t version;
 114
 115   /*
 116    * Type of message, see below.
 117    */
 118   uint8_t msg_type;
 119
 120   /*
 121    * Length of entire message, including the header, in network byte
 122    * order.
 123    *
 124    * Note that msg_len is rounded up to make sure that message is at
 125    * the desired alignment. This means that some payloads may need
 126    * padding at the end.
 127    */
 128   uint16_t msg_len;
 129 } fpm_msg_hdr_t;
 130
 131 /*
 132  * The current version of the FPM protocol is 1.
 133  */
 134 #define FPM_PROTO_VERSION 1
 135
 136 typedef enum fpm_msg_type_e_ {
 137   FPM_MSG_TYPE_NONE = 0,
 138
 139   /*
 140    * Indicates that the payload is a completely formed netlink
 141    * message.
 142    */
 143   FPM_MSG_TYPE_NETLINK = 1,
 144 } fpm_msg_type_e;
 145
 146 /*
 147  * The FPM message header is aligned to the same boundary as netlink
 148  * messages (4). This means that a netlink message does not need
 149  * padding when encapsulated in an FPM message.
 150  */
 151 #define FPM_MSG_ALIGNTO 4
 152
 153 /*
 154  * fpm_msg_align
 155  *
 156  * Round up the given length to the desired alignment.
 157  */
 158 static inline size_t
 159 fpm_msg_align (size_t len)
 160 {
 161   return (len + FPM_MSG_ALIGNTO - 1) & ~(FPM_MSG_ALIGNTO - 1);
 162 }
 163
 164 /*
 165  * The (rounded up) size of the FPM message header. This ensures that
 166  * the message payload always starts at an aligned address.
 167  */
 168 #define FPM_MSG_HDR_LEN (fpm_msg_align (sizeof (fpm_msg_hdr_t)))
 169
 170 /*
 171  * fpm_data_len_to_msg_len
 172  *
 173  * The length value that should be placed in the msg_len field of the
 174  * header for a *payload* of size 'data_len'.
 175  */
 176 static inline size_t
 177 fpm_data_len_to_msg_len (size_t data_len)
 178 {
 179   return fpm_msg_align (data_len) + FPM_MSG_HDR_LEN;
 180 }
 181
 182 /*
 183  * fpm_msg_data
 184  *
 185  * Pointer to the payload of the given fpm header.
 186  */
 187 static inline void *
 188 fpm_msg_data (fpm_msg_hdr_t *hdr)
 189 {
 190   return ((char*) hdr) + FPM_MSG_HDR_LEN;
 191 }
 192
 193 /*
 194  * fpm_msg_len
 195  */
 196 static inline size_t
 197 fpm_msg_len (const fpm_msg_hdr_t *hdr)
 198 {
 199   return ntohs (hdr->msg_len);
 200 }
 201
 202 /*
 203  * fpm_msg_data_len
 204  */
 205 static inline size_t
 206 fpm_msg_data_len (const fpm_msg_hdr_t *hdr)
 207 {
 208   return (fpm_msg_len (hdr) - FPM_MSG_HDR_LEN);
 209 }
 210
 211 /*
 212  * fpm_msg_next
 213  *
 214  * Move to the next message in a buffer.
 215  */
 216 static inline fpm_msg_hdr_t *
 217 fpm_msg_next (fpm_msg_hdr_t *hdr, size_t *len)
 218 {
 219   size_t msg_len;
 220
 221   msg_len = fpm_msg_len (hdr);
 222
 223   if (len) {
 224     if (*len < msg_len)
 225       {
 226         assert(0);
 227         return NULL;
 228       }
 229     *len -= msg_len;
 230   }
 231
 232   return (fpm_msg_hdr_t *) (((char*) hdr) + msg_len);
 233 }
 234
 235 /*
 236  * fpm_msg_hdr_ok
 237  *
 238  * Returns TRUE if a message header looks well-formed.
 239  */
 240 static inline int
 241 fpm_msg_hdr_ok (const fpm_msg_hdr_t *hdr)
 242 {
 243   size_t msg_len;
 244
 245   if (hdr->msg_type == FPM_MSG_TYPE_NONE)
 246     return 0;
 247
 248   msg_len = fpm_msg_len (hdr);
 249
 250   if (msg_len < FPM_MSG_HDR_LEN || msg_len > FPM_MAX_MSG_LEN)
 251     return 0;
 252
 253   if (fpm_msg_align (msg_len) != msg_len)
 254     return 0;
 255
 256   return 1;
 257 }
 258
 259 /*
 260  * fpm_msg_ok
 261  *
 262  * Returns TRUE if a message looks well-formed.
 263  *
 264  * @param len The length in bytes from 'hdr' to the end of the buffer.
 265  */
 266 static inline int
 267 fpm_msg_ok (const fpm_msg_hdr_t *hdr, size_t len)
 268 {
 269   if (len < FPM_MSG_HDR_LEN)
 270     return 0;
 271
 272   if (!fpm_msg_hdr_ok (hdr))
 273     return 0;
 274
 275   if (fpm_msg_len (hdr) > len)
 276     return 0;
 277
 278   return 1;
 279 }
 280
 281 // tcp maximum range
 282 #define TCP_MAX_PORT   65535
 283
 284 // tcp minimum range
 285 #define TCP_MIN_PORT   1
 286
 287 #endif /* _FPM_H */