VNFs/vCGNAPT/pipeline/cgnapt_pcp_be.h

   1 /*
   2 // Copyright (c) 2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #ifndef _CGNAPT_PCP_H_
  18 #define _CGNAPT_PCP_H_
  19 /**
  20  * @file
  21  *
  22  * PCP-related defines
  23  */
  24
  25 #include <stdint.h>
  26 #include <rte_ether.h>
  27 #include <rte_udp.h>
  28 #include <rte_pipeline.h>
  29 #include <rte_ip.h>
  30 #include "pipeline_cgnapt_common.h"
  31
  32 void handle_pcp_req(struct rte_mbuf *rx_pkt,
  33                                         uint8_t ver,
  34                                         void *pipeline_cgnapt_ptr);
  35
  36 void construct_pcp_resp(struct rte_mbuf *rx_pkt,
  37                                         struct rte_mbuf *tx_pkt,
  38                                         uint8_t ver,
  39                                         struct rte_pipeline *rte_p);
  40
  41 void *pipeline_cgnapt_msg_req_pcp_handler(
  42                                         __rte_unused struct pipeline *p,
  43                                         void *msg);
  44
  45 #ifdef __cplusplus
  46 extern "C" {
  47 #endif
  48
  49 /************************** Constats used in PCP ****************************/
  50 #define PCP_SERVER_PORT 5351
  51
  52 /* PCP Req or Resp */
  53 enum{
  54         PCP_REQ,
  55         PCP_RESP,
  56 };
  57 /* PCP life time in seconds */
  58 enum{
  59         PCP_LONG_LTIME = 30 * 60,
  60         PCP_SHORT_LTIME = 30,
  61         MAX_PCP_LIFE_TIME = 120 * 60,
  62 };
  63 /* PCP opcodes */
  64 enum{
  65         PCP_ANNOUNCE,
  66         PCP_MAP,
  67         PCP_PEER,
  68 };
  69
  70 /* PCP result codes */
  71 enum{
  72         PCP_SUCCESS,
  73         PCP_UNSUPP_VERSION,
  74         PCP_NOT_AUTHORIZED,
  75         PCP_MALFORMED_REQUEST,
  76         PCP_UNSUPP_OPCODE,
  77         PCP_UNSUPP_OPTION,
  78         PCP_MALFORMED_OPTION,
  79         PCP_NETWORK_FAILURE,
  80         PCP_NO_RESOURCES,
  81         PCP_UNSUPP_PROTOCOL,
  82         PCP_USER_EX_QUOTA,
  83         PCP_CANNOT_PROVIDE_EXTERNAL,
  84         PCP_ADDRESS_MISMATCH,
  85         PCP_EXCESSIVE_REMOTE_PEERS
  86 };
  87
  88 /*
  89  * @struct
  90  *
  91  * PCP request header format
  92  */
  93 struct pcp_req_hdr {
  94         uint8_t ver;
  95         uint8_t opcode:7; //First LSB
  96         uint8_t req_resp:1;// MSB
  97         uint16_t res_unuse;
  98         uint32_t life_time;
  99         uint32_t cli_ip[4];
 100 } __attribute__((__packed__));
 101
 102 /*
 103  * @struct
 104  *
 105  * PCP response header format
 106  */
 107 struct pcp_resp_hdr {
 108         uint8_t ver;
 109         uint8_t opcode:7; //First LSB
 110         uint8_t req_resp:1;// MSB
 111         uint8_t res_unuse;
 112         uint8_t result_code;
 113         uint32_t life_time;
 114         uint32_t epoch_time;
 115         uint32_t reserve[3];
 116 } __attribute__((__packed__));
 117
 118 /*
 119  * @struct
 120  *
 121  * PCP MAP request header format
 122  */
 123 struct pcp_map_req {
 124         uint32_t nonce[3];
 125         uint8_t protocol;
 126         uint32_t res_unuse1:24;
 127         uint16_t int_port;
 128         uint16_t ext_port;
 129         uint32_t ext_ip[4];
 130 } __attribute__((__packed__));
 131
 132 /*
 133  * @struct
 134  *
 135  * PCP MAP response header format
 136  */
 137 struct pcp_map_resp {
 138         uint32_t nonce[3];
 139         uint8_t protocol;
 140         uint32_t res_unuse1:24;
 141         uint16_t int_port;
 142         uint16_t ext_port;
 143         uint32_t ext_ip[4];
 144 } __attribute__((__packed__));
 145
 146 /*
 147  * @struct
 148  *
 149  * PCP PEER request header format
 150  */
 151 struct pcp_peer_req {
 152         uint32_t nonce[3];
 153         uint8_t protocol;
 154         uint32_t res_unuse1:24;
 155         uint16_t int_port;
 156         uint16_t ext_port;
 157         uint32_t ext_ip[4];
 158         uint16_t rpeer_port;
 159         uint16_t res_unuse2;
 160         uint32_t rpeer_ip[4];
 161 } __attribute__((__packed__));
 162
 163 /*
 164  * @struct
 165  *
 166  * PCP PEER response header format
 167  */
 168 struct pcp_peer_resp {
 169         uint32_t nonce[3];
 170         uint8_t protocol;
 171         uint32_t res_unuse1:24;
 172         uint16_t int_port;
 173         uint16_t ext_port;
 174         uint32_t ext_ip[4];
 175         uint16_t rpeer_port;
 176         uint16_t res_unuse2;
 177         uint32_t rpeer_ip[4];
 178 } __attribute__((__packed__));
 179
 180 /*
 181  * @struct
 182  *
 183  * Customized IPv4 header of struct ipv4_hdr
 184  */
 185 struct ipv4 {
 186         uint8_t  version_ihl;           /**< version and header length */
 187         uint8_t  type_of_service;       /**< type of service */
 188         uint16_t total_length;          /**< length of packet */
 189         uint16_t packet_id;             /**< packet ID */
 190         uint16_t fragment_offset;       /**< fragmentation offset */
 191         uint8_t  time_to_live;          /**< time to live */
 192         uint8_t  next_proto_id;         /**< protocol ID */
 193         uint16_t hdr_checksum;          /**< header checksum */
 194         uint32_t src_addr;              /**< source address */
 195         uint32_t dst_addr;              /**< destination address */
 196         uint16_t src_port;
 197         uint16_t dst_port;
 198 } __attribute__((__packed__));
 199
 200 /*
 201  * @struct
 202  *
 203  * Customized IPv6 header of struct ipv6_hdr
 204  */
 205 struct ipv6 {
 206         uint32_t vtc_flow;     /**< IP version, traffic class & flow label. */
 207         uint16_t payload_len;  /**< IP packet length -
 208                                 * includes sizeof(ip_header).
 209                                 */
 210         uint8_t  proto;        /**< Protocol, next header. */
 211         uint8_t  hop_limits;   /**< Hop limits. */
 212         uint8_t  src_addr[16]; /**< IP address of source host. */
 213         uint8_t  dst_addr[16]; /**< IP address of destination host(s). */
 214         uint16_t src_port;
 215         uint16_t dst_port;
 216
 217 } __attribute__((__packed__));
 218
 219 /*
 220  * @struct
 221  *
 222  *  To represent the entire pkt data in one structure
 223  */
 224 struct pcp_pkt {
 225         struct ether_hdr eth;
 226         union{
 227                 struct ipv4 ipv4;
 228                 struct ipv6 ipv6;
 229         };
 230 } __attribute__((__packed__));
 231
 232 /**
 233  * A structure defining the PCP msg request
 234  */
 235 struct pipeline_cgnapt_pcp_msg_req {
 236         enum pipeline_msg_req_type type;
 237         enum pipeline_cgnapt_msg_req_type subtype;
 238
 239         /* data */
 240         uint8_t cmd;
 241         uint32_t lifetime;
 242 };
 243
 244 /**
 245  * A structure defining the PCP cmd response message.
 246  */
 247 struct pipeline_cgnapt_pcp_msg_rsp {
 248         int status;
 249 };
 250
 251
 252 /* All required offsets */
 253 enum{
 254         MBUF_HEAD_ROOM = 256,
 255         ETH_HDR_SZ = 14,
 256         IPV4_HDR_SZ = 20,
 257         IPV6_HDR_SZ = 40,
 258         IPV4_SZ = 4,
 259         IPV6_SZ = 6,
 260         TCP_HDR_SZ = 20,
 261         UDP_HDR_SZ = 8,
 262         PCP_REQ_RESP_HDR_SZ = 24,
 263         PCP_MAP_REQ_RESP_SZ = 36,
 264         PCP_PEER_REQ_RESP_SZ = 56,
 265 };
 266
 267 enum{
 268         ETH_DST_MAC     = MBUF_HEAD_ROOM,
 269         ETH_SRC_MAC     = MBUF_HEAD_ROOM + 6,
 270         PKT_TYPE                = MBUF_HEAD_ROOM + 12,
 271         IP_OFFSET       = MBUF_HEAD_ROOM + ETH_HDR_SZ,
 272
 273 /* IPV4 Offsets */
 274
 275         IPV4_PROTOCOL           = MBUF_HEAD_ROOM + ETH_HDR_SZ + 9,
 276         IPV4_SRC_ADD_OFST       = MBUF_HEAD_ROOM + ETH_HDR_SZ + 12,
 277         IPV4_DST_ADD_OFST       = MBUF_HEAD_ROOM + ETH_HDR_SZ + 12 + IPV4_SZ,
 278
 279         IPV4_TCP_OFST           = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ,
 280         IPV4_TCP_SRC_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ,
 281         IPV4_TCP_DST_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ + 2,
 282
 283         IPV4_UDP_OFST           = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ,
 284         IPV4_UDP_SRC_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ,
 285         IPV4_UDP_DST_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ + 2,
 286
 287         IPV4_PCP_OFST                    = MBUF_HEAD_ROOM + ETH_HDR_SZ +
 288                                         IPV4_HDR_SZ + UDP_HDR_SZ,
 289         IPV4_PCP_MAP_OFST                = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ +
 290                                         UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ,
 291         IPV4_PCP_PEER_OFST               = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV4_HDR_SZ +
 292                                         UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ,
 293
 294         IPV4_PCP_MAP_PL_LEN = IPV4_HDR_SZ + UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ +
 295                                         PCP_MAP_REQ_RESP_SZ,
 296         IPV4_PCP_PEER_PL_LEN = IPV4_HDR_SZ + UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ +
 297                                         PCP_PEER_REQ_RESP_SZ,
 298 /* IPV6 Offsets */
 299
 300         IPV6_PROTOCOL           = MBUF_HEAD_ROOM + ETH_HDR_SZ + 6,
 301         IPV6_SRC_ADD_OFST       = MBUF_HEAD_ROOM + ETH_HDR_SZ + 8,
 302         IPV6_DST_ADD_OFST       = MBUF_HEAD_ROOM + ETH_HDR_SZ + 8 + IPV6_SZ,
 303
 304         IPV6_TCP_OFST           = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ,
 305         IPV6_TCP_SRC_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ,
 306         IPV6_TCP_DST_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ + 2,
 307
 308         IPV6_UDP_OFST           = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ,
 309         IPV6_UCP_SRC_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ,
 310         IPV6_UCP_DST_PORT_OFST = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ + 2,
 311
 312         IPV6_PCP_OFST                    = MBUF_HEAD_ROOM + ETH_HDR_SZ +
 313                                         IPV6_HDR_SZ + UDP_HDR_SZ,
 314         IPV6_PCP_MAP_OFST                = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ +
 315                                         UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ,
 316         IPV6_PCP_PEER_OFST               = MBUF_HEAD_ROOM + ETH_HDR_SZ + IPV6_HDR_SZ +
 317                                         UDP_HDR_SZ + PCP_REQ_RESP_HDR_SZ,
 318
 319         IPV6_PCP_MAP_PL_LEN = IPV6_HDR_SZ + UDP_HDR_SZ +
 320                                 PCP_REQ_RESP_HDR_SZ + PCP_MAP_REQ_RESP_SZ,
 321         IPV6_PCP_PEER_PL_LEN = IPV6_HDR_SZ + UDP_HDR_SZ +
 322                                 PCP_REQ_RESP_HDR_SZ + PCP_PEER_REQ_RESP_SZ,
 323 };
 324
 325 enum{
 326 STATIC_CGNAPT_TIMEOUT = -1,
 327 DYNAMIC_CGNAPT_TIMEOUT = 0,
 328 };
 329
 330 enum PCP_RET {
 331 PCP_INIT_SUCCESS,
 332 PCP_INIT_UNSUCCESS,
 333 PCP_PCP_PKT,
 334 //PCP_PCP_PKT_SUCCESS,
 335 PCP_NOT_PCP_PKT,
 336 PCP_PKT_CORRUPT,
 337 };
 338
 339
 340 uint8_t  _PCP_DEBUG;
 341 uint32_t pcp_success_count;
 342 uint32_t pcp_error_count;
 343 uint32_t pcp_entry_count;
 344 uint32_t pcp_enable;
 345
 346 uint8_t pcp_pool_init;
 347 struct rte_mempool *pcp_mbuf_pool;
 348
 349 enum PCP_RET pcp_init(void);
 350
 351
 352 #ifdef __cplusplus
 353 }
 354 #endif
 355
 356 #endif /* CGNAPT_PCP_H_ */