sys/netgraph/netflow/ng_netflow.h

   1 /*-
   2  * Copyright (c) 2010-2011 Alexander V. Chernikov <melifaro@ipfw.ru>
   3  * Copyright (c) 2004-2005 Gleb Smirnoff <glebius@FreeBSD.org>
   4  * Copyright (c) 2001-2003 Roman V. Palagin <romanp@unshadow.net>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  *       $SourceForge: ng_netflow.h,v 1.26 2004/09/04 15:44:55 glebius Exp $
  29  *       $FreeBSD$
  30  */
  31
  32 #ifndef _NG_NETFLOW_H_
  33 #define _NG_NETFLOW_H_
  34
  35 #define NG_NETFLOW_NODE_TYPE    "netflow"
  36 #define NGM_NETFLOW_COOKIE      1309868867
  37
  38 #define NG_NETFLOW_MAXIFACES    USHRT_MAX
  39
  40 /* Hook names */
  41
  42 #define NG_NETFLOW_HOOK_DATA    "iface"
  43 #define NG_NETFLOW_HOOK_OUT     "out"
  44 #define NG_NETFLOW_HOOK_EXPORT  "export"
  45 #define NG_NETFLOW_HOOK_EXPORT9 "export9"
  46
  47 /* This define effectively disable (v5) netflow export hook! */
  48 /* #define COUNTERS_64 */
  49
  50 /* Netgraph commands understood by netflow node */
  51 enum {
  52     NGM_NETFLOW_INFO = 1|NGM_READONLY|NGM_HASREPLY,     /* get node info */
  53     NGM_NETFLOW_IFINFO = 2|NGM_READONLY|NGM_HASREPLY,   /* get iface info */
  54     NGM_NETFLOW_SHOW = 3|NGM_READONLY|NGM_HASREPLY,     /* show ip cache flow */
  55     NGM_NETFLOW_SETDLT          = 4,    /* set data-link type */
  56     NGM_NETFLOW_SETIFINDEX      = 5,    /* set interface index */
  57     NGM_NETFLOW_SETTIMEOUTS     = 6,    /* set active/inactive flow timeouts */
  58     NGM_NETFLOW_SETCONFIG       = 7,    /* set flow generation options */
  59     NGM_NETFLOW_SETTEMPLATE     = 8,    /* set v9 flow template periodic */
  60     NGM_NETFLOW_SETMTU          = 9,    /* set outgoing interface MTU */
  61 };
  62
  63 /* This structure is returned by the NGM_NETFLOW_INFO message */
  64 struct ng_netflow_info {
  65         uint64_t        nfinfo_bytes;           /* accounted IPv4 bytes */
  66         uint32_t        nfinfo_packets;         /* accounted IPv4 packets */
  67         uint64_t        nfinfo_bytes6;          /* accounted IPv6 bytes */
  68         uint32_t        nfinfo_packets6;        /* accounted IPv6 packets */
  69         uint64_t        nfinfo_sbytes;          /* skipped IPv4 bytes */
  70         uint32_t        nfinfo_spackets;        /* skipped IPv4 packets */
  71         uint64_t        nfinfo_sbytes6;         /* skipped IPv6 bytes */
  72         uint32_t        nfinfo_spackets6;       /* skipped IPv6 packets */
  73         uint32_t        nfinfo_used;            /* used cache records */
  74         uint32_t        nfinfo_used6;           /* used IPv6 cache records */
  75         uint32_t        nfinfo_alloc_failed;    /* failed allocations */
  76         uint32_t        nfinfo_export_failed;   /* failed exports */
  77         uint32_t        nfinfo_export9_failed;  /* failed exports */
  78         uint32_t        nfinfo_realloc_mbuf;    /* reallocated mbufs */
  79         uint32_t        nfinfo_alloc_fibs;      /* fibs allocated */
  80         uint32_t        nfinfo_act_exp;         /* active expiries */
  81         uint32_t        nfinfo_inact_exp;       /* inactive expiries */
  82         uint32_t        nfinfo_inact_t;         /* flow inactive timeout */
  83         uint32_t        nfinfo_act_t;           /* flow active timeout */
  84 };
  85
  86 /* This structure is returned by the NGM_NETFLOW_IFINFO message */
  87 struct ng_netflow_ifinfo {
  88         uint32_t        ifinfo_packets; /* number of packets for this iface */
  89         uint8_t         ifinfo_dlt;     /* Data Link Type, DLT_XXX */
  90 #define MAXDLTNAMELEN   20
  91         u_int16_t       ifinfo_index;   /* connected iface index */
  92         uint32_t        conf;
  93 };
  94
  95
  96 /* This structure is passed to NGM_NETFLOW_SETDLT message */
  97 struct ng_netflow_setdlt {
  98         uint16_t iface;         /* which iface dlt change */
  99         uint8_t  dlt;                   /* DLT_XXX from bpf.h */
 100 };
 101
 102 /* This structure is passed to NGM_NETFLOW_SETIFINDEX */
 103 struct ng_netflow_setifindex {
 104         u_int16_t iface;                /* which iface index change */
 105         u_int16_t index;                /* new index */
 106 };
 107
 108 /* This structure is passed to NGM_NETFLOW_SETTIMEOUTS */
 109 struct ng_netflow_settimeouts {
 110         uint32_t        inactive_timeout;       /* flow inactive timeout */
 111         uint32_t        active_timeout;         /* flow active timeout */
 112 };
 113
 114 #define NG_NETFLOW_CONF_INGRESS         1
 115 #define NG_NETFLOW_CONF_EGRESS          2
 116 #define NG_NETFLOW_CONF_ONCE            4
 117 #define NG_NETFLOW_CONF_THISONCE        8
 118
 119 /* This structure is passed to NGM_NETFLOW_SETCONFIG */
 120 struct ng_netflow_setconfig {
 121         u_int16_t iface;                /* which iface config change */
 122         u_int32_t conf;                 /* new config */
 123 };
 124
 125 /* This structure is passed to NGM_NETFLOW_SETTEMPLATE */
 126 struct ng_netflow_settemplate {
 127         uint16_t time;          /* max time between announce */
 128         uint16_t packets;       /* max packets between announce */
 129 };
 130
 131 /* This structure is passed to NGM_NETFLOW_SETMTU */
 132 struct ng_netflow_setmtu {
 133         uint16_t mtu;           /* MTU for packet */
 134 };
 135
 136 /* This structure is used in NGM_NETFLOW_SHOW request/responce */
 137 struct ngnf_show_header {
 138         u_char          version;        /* IPv4 or IPv6 */
 139         uint32_t        hash_id;        /* current hash index */
 140         uint32_t        list_id;        /* current record number in given hash */
 141         uint32_t        nentries;       /* number of records in response */
 142 };
 143
 144 /* XXXGL
 145  * Somewhere flow_rec6 is casted to flow_rec, and flow6_entry_data is
 146  * casted to flow_entry_data. After casting, fle->r.fib is accessed.
 147  * So beginning of these structs up to fib should be kept common.
 148  */
 149
 150 /* This is unique data, which identifies flow */
 151 struct flow_rec {
 152         uint16_t        flow_type; /* IPv4 L4/L3 flow, see NETFLOW_V9_FLOW* */
 153         uint16_t        fib;
 154         struct in_addr  r_src;
 155         struct in_addr  r_dst;
 156         union {
 157                 struct {
 158                         uint16_t        s_port; /* source TCP/UDP port */
 159                         uint16_t        d_port; /* destination TCP/UDP port */
 160                 } dir;
 161                 uint32_t both;
 162         } ports;
 163         union {
 164                 struct {
 165                         u_char          prot;   /* IP protocol */
 166                         u_char          tos;    /* IP TOS */
 167                         uint16_t        i_ifx;  /* input interface index */
 168                 } i;
 169                 uint32_t all;
 170         } misc;
 171 };
 172
 173 /* This is unique data, which identifies flow */
 174 struct flow6_rec {
 175         uint16_t        flow_type; /* IPv4 L4/L3 Ipv6 L4/L3 flow, see NETFLOW_V9_FLOW* */
 176         uint16_t        fib;
 177         union {
 178                 struct in_addr  r_src;
 179                 struct in6_addr r_src6;
 180         } src;
 181         union {
 182                 struct in_addr  r_dst;
 183                 struct in6_addr r_dst6;
 184         } dst;
 185         union {
 186                 struct {
 187                         uint16_t        s_port; /* source TCP/UDP port */
 188                         uint16_t        d_port; /* destination TCP/UDP port */
 189                 } dir;
 190                 uint32_t both;
 191         } ports;
 192         union {
 193                 struct {
 194                         u_char          prot;   /* IP protocol */
 195                         u_char          tos;    /* IP TOS */
 196                         uint16_t        i_ifx;  /* input interface index */
 197                 } i;
 198                 uint32_t all;
 199         } misc;
 200 };
 201
 202 #define r_ip_p  misc.i.prot
 203 #define r_tos   misc.i.tos
 204 #define r_i_ifx misc.i.i_ifx
 205 #define r_misc  misc.all
 206 #define r_ports ports.both
 207 #define r_sport ports.dir.s_port
 208 #define r_dport ports.dir.d_port
 209
 210 /* A flow entry which accumulates statistics */
 211 struct flow_entry_data {
 212         uint16_t                version;        /* Protocol version */
 213         struct flow_rec         r;
 214         struct in_addr          next_hop;
 215         uint16_t                fle_o_ifx;      /* output interface index */
 216 #define                         fle_i_ifx       r.misc.i.i_ifx
 217         uint8_t         dst_mask;       /* destination route mask bits */
 218         uint8_t         src_mask;       /* source route mask bits */
 219         u_long                  packets;
 220         u_long                  bytes;
 221         long                    first;  /* uptime on first packet */
 222         long                    last;   /* uptime on last packet */
 223         u_char                  tcp_flags;      /* cumulative OR */
 224 };
 225
 226 struct flow6_entry_data {
 227         uint16_t                version;        /* Protocol version */
 228         struct flow6_rec        r;
 229         union {
 230                 struct in_addr          next_hop;
 231                 struct in6_addr         next_hop6;
 232         } n;
 233         uint16_t                fle_o_ifx;      /* output interface index */
 234 #define                         fle_i_ifx       r.misc.i.i_ifx
 235         uint8_t         dst_mask;       /* destination route mask bits */
 236         uint8_t         src_mask;       /* source route mask bits */
 237         u_long                  packets;
 238         u_long                  bytes;
 239         long                    first;  /* uptime on first packet */
 240         long                    last;   /* uptime on last packet */
 241         u_char                  tcp_flags;      /* cumulative OR */
 242 };
 243
 244 /*
 245  * How many flow records we will transfer at once
 246  * without overflowing socket receive buffer
 247  */
 248 #define NREC_AT_ONCE            1000
 249 #define NREC6_AT_ONCE           (NREC_AT_ONCE * sizeof(struct flow_entry_data) / \
 250                                 sizeof(struct flow6_entry_data))
 251 #define NGRESP_SIZE             (sizeof(struct ngnf_show_header) + (NREC_AT_ONCE * \
 252                                 sizeof(struct flow_entry_data)))
 253 #define SORCVBUF_SIZE           (NGRESP_SIZE + 2 * sizeof(struct ng_mesg))
 254
 255 /* Everything below is for kernel */
 256
 257 #ifdef _KERNEL
 258
 259 struct flow_entry {
 260         TAILQ_ENTRY(flow_entry) fle_hash;       /* entries in hash slot */
 261         struct flow_entry_data  f;
 262 };
 263
 264 struct flow6_entry {
 265         TAILQ_ENTRY(flow_entry) fle_hash;       /* entries in hash slot */
 266         struct flow6_entry_data f;
 267 };
 268 /* Parsing declarations */
 269
 270 /* Parse the info structure */
 271 #define NG_NETFLOW_INFO_TYPE    {                       \
 272         { "IPv4 bytes",         &ng_parse_uint64_type },        \
 273         { "IPv4 packets",       &ng_parse_uint32_type },        \
 274         { "IPv6 bytes",         &ng_parse_uint64_type },        \
 275         { "IPv6 packets",       &ng_parse_uint32_type },        \
 276         { "IPv4 skipped bytes",         &ng_parse_uint64_type },        \
 277         { "IPv4 skipped packets",       &ng_parse_uint32_type },        \
 278         { "IPv6 skipped bytes",         &ng_parse_uint64_type },        \
 279         { "IPv6 skipped packets",       &ng_parse_uint32_type },        \
 280         { "IPv4 records used",  &ng_parse_uint32_type },\
 281         { "IPv6 records used",  &ng_parse_uint32_type },\
 282         { "Failed allocations", &ng_parse_uint32_type },\
 283         { "V5 failed exports",  &ng_parse_uint32_type },\
 284         { "V9 failed exports",  &ng_parse_uint32_type },\
 285         { "mbuf reallocations", &ng_parse_uint32_type },\
 286         { "fibs allocated",     &ng_parse_uint32_type },\
 287         { "Active expiries",    &ng_parse_uint32_type },\
 288         { "Inactive expiries",  &ng_parse_uint32_type },\
 289         { "Inactive timeout",   &ng_parse_uint32_type },\
 290         { "Active timeout",     &ng_parse_uint32_type },\
 291         { NULL }                                        \
 292 }
 293
 294 /* Parse the ifinfo structure */
 295 #define NG_NETFLOW_IFINFO_TYPE  {                       \
 296         { "packets",    &ng_parse_uint32_type },        \
 297         { "data link type", &ng_parse_uint8_type },     \
 298         { "index", &ng_parse_uint16_type },             \
 299         { "conf", &ng_parse_uint32_type },              \
 300         { NULL }                                        \
 301 }
 302
 303 /* Parse the setdlt structure */
 304 #define NG_NETFLOW_SETDLT_TYPE {                        \
 305         { "iface",      &ng_parse_uint16_type },        \
 306         { "dlt",        &ng_parse_uint8_type  },        \
 307         { NULL }                                        \
 308 }
 309
 310 /* Parse the setifindex structure */
 311 #define NG_NETFLOW_SETIFINDEX_TYPE {                    \
 312         { "iface",      &ng_parse_uint16_type },        \
 313         { "index",      &ng_parse_uint16_type },        \
 314         { NULL }                                        \
 315 }
 316
 317 /* Parse the settimeouts structure */
 318 #define NG_NETFLOW_SETTIMEOUTS_TYPE {                   \
 319         { "inactive",   &ng_parse_uint32_type },        \
 320         { "active",     &ng_parse_uint32_type },        \
 321         { NULL }                                        \
 322 }
 323
 324 /* Parse the setifindex structure */
 325 #define NG_NETFLOW_SETCONFIG_TYPE {                     \
 326         { "iface",      &ng_parse_uint16_type },        \
 327         { "conf",       &ng_parse_uint32_type },        \
 328         { NULL }                                        \
 329 }
 330
 331 /* Parse the settemplate structure */
 332 #define NG_NETFLOW_SETTEMPLATE_TYPE {           \
 333         { "time",       &ng_parse_uint16_type },        \
 334         { "packets",    &ng_parse_uint16_type },        \
 335         { NULL }                                        \
 336 }
 337
 338 /* Parse the setmtu structure */
 339 #define NG_NETFLOW_SETMTU_TYPE {                        \
 340         { "mtu",        &ng_parse_uint16_type },        \
 341         { NULL }                                        \
 342 }
 343
 344 /* Private hook data */
 345 struct ng_netflow_iface {
 346         hook_p          hook;           /* NULL when disconnected */
 347         hook_p          out;            /* NULL when no bypass hook */
 348         struct ng_netflow_ifinfo        info;
 349 };
 350
 351 typedef struct ng_netflow_iface *iface_p;
 352 typedef struct ng_netflow_ifinfo *ifinfo_p;
 353
 354 struct netflow_export_item {
 355         item_p          item;
 356         item_p          item9;
 357         struct netflow_v9_packet_opt    *item9_opt;
 358 };
 359
 360 /* Structure contatining fib-specific data */
 361 struct fib_export {
 362         uint32_t                        fib;            /* kernel fib id */
 363         struct netflow_export_item      exp;            /* Various data used for export */
 364         struct mtx                      export_mtx;     /* exp.item mutex */
 365         struct mtx                      export9_mtx;    /* exp.item9 mutex */
 366         uint32_t                        flow_seq;       /* current V5 flow sequence */
 367         uint32_t                        flow9_seq;      /* current V9 flow sequence */
 368         uint32_t                        domain_id;      /* Observartion domain id */
 369         /* Netflow V9 counters */
 370         uint32_t                        templ_last_ts;  /* unixtime of last template announce */
 371         uint32_t                        templ_last_pkt; /* packets count on last template announce */
 372         uint32_t                        sent_packets;   /* packets sent by exporter; */
 373         struct netflow_v9_packet_opt    *export9_opt;   /* current packet specific options */
 374 };
 375
 376 typedef struct fib_export *fib_export_p;
 377
 378 /* Structure describing our flow engine */
 379 struct netflow {
 380         node_p                  node;           /* link to the node itself */
 381         hook_p                  export;         /* export data goes there */
 382         hook_p                  export9;        /* Netflow V9 export data goes there */
 383
 384         struct ng_netflow_info  info;
 385         struct callout          exp_callout;    /* expiry periodic job */
 386
 387         /*
 388          * Flow entries are allocated in uma(9) zone zone. They are
 389          * indexed by hash hash. Each hash element consist of tailqueue
 390          * head and mutex to protect this element.
 391          */
 392 #define CACHESIZE                       (65536*4)
 393 #define CACHELOWAT                      (CACHESIZE * 3/4)
 394 #define CACHEHIGHWAT                    (CACHESIZE * 9/10)
 395         uma_zone_t              zone;
 396         struct flow_hash_entry  *hash;
 397
 398         /*
 399          * NetFlow data export
 400          *
 401          * export_item is a data item, it has an mbuf with cluster
 402          * attached to it. A thread detaches export_item from priv
 403          * and works with it. If the export is full it is sent, and
 404          * a new one is allocated. Before exiting thread re-attaches
 405          * its current item back to priv. If there is item already,
 406          * current incomplete datagram is sent.
 407          * export_mtx is used for attaching/detaching.
 408          */
 409
 410         /* IPv6 support */
 411 #ifdef INET6
 412         uma_zone_t              zone6;
 413         struct flow_hash_entry  *hash6;
 414 #endif
 415         /* Multiple FIB support */
 416         fib_export_p            fib_data[RT_NUMFIBS]; /* array of pointers to fib-specific data */
 417
 418         /*
 419          * RFC 3954 clause 7.3
 420          * "Both options MUST be configurable by the user on the Exporter."
 421          */
 422         uint16_t                templ_time;     /* time between sending templates */
 423         uint16_t                templ_packets;  /* packets between sending templates */
 424 #define NETFLOW_V9_MAX_FLOWSETS 2
 425         u_char                  flowsets_count; /* current flowsets used */
 426         u_char                  flowset_records[NETFLOW_V9_MAX_FLOWSETS - 1]; /* Count of records in each flowset */
 427         uint16_t                mtu;            /* export interface MTU */
 428         struct netflow_v9_flowset_header        *v9_flowsets[NETFLOW_V9_MAX_FLOWSETS - 1]; /* Pointers to pre-compiled flowsets */
 429
 430         struct ng_netflow_iface ifaces[NG_NETFLOW_MAXIFACES];
 431 };
 432
 433 typedef struct netflow *priv_p;
 434
 435 /* Header of a small list in hash cell */
 436 struct flow_hash_entry {
 437         struct mtx              mtx;
 438         TAILQ_HEAD(fhead, flow_entry) head;
 439 };
 440
 441 #define ERROUT(x)       { error = (x); goto done; }
 442
 443 #define MTAG_NETFLOW            1221656444
 444 #define MTAG_NETFLOW_CALLED     0
 445
 446 #define m_pktlen(m)     ((m)->m_pkthdr.len)
 447 #define IP6VERSION      6
 448
 449 #define priv_to_fib(priv, fib)  (priv)->fib_data[(fib)]
 450
 451 /*
 452  * Cisco uses milliseconds for uptime. Bad idea, since it overflows
 453  * every 48+ days. But we will do same to keep compatibility. This macro
 454  * does overflowable multiplication to 1000.
 455  */
 456 #define MILLIUPTIME(t)  (((t) << 9) +   /* 512 */       \
 457                          ((t) << 8) +   /* 256 */       \
 458                          ((t) << 7) +   /* 128 */       \
 459                          ((t) << 6) +   /* 64  */       \
 460                          ((t) << 5) +   /* 32  */       \
 461                          ((t) << 3))    /* 8   */
 462
 463 /* Prototypes for netflow.c */
 464 void    ng_netflow_cache_init(priv_p);
 465 void    ng_netflow_cache_flush(priv_p);
 466 int     ng_netflow_fib_init(priv_p priv, int fib);
 467 void    ng_netflow_copyinfo(priv_p, struct ng_netflow_info *);
 468 timeout_t ng_netflow_expire;
 469 int     ng_netflow_flow_add(priv_p, fib_export_p, struct ip *, caddr_t, uint8_t, uint8_t, unsigned int);
 470 int     ng_netflow_flow6_add(priv_p, fib_export_p, struct ip6_hdr *, caddr_t , uint8_t, uint8_t, unsigned int);
 471 int     ng_netflow_flow_show(priv_p, struct ngnf_show_header *req, struct ngnf_show_header *resp);
 472
 473 void    ng_netflow_v9_cache_init(priv_p);
 474 void    ng_netflow_v9_cache_flush(priv_p);
 475 item_p  get_export9_dgram(priv_p, fib_export_p, struct netflow_v9_packet_opt **);
 476 void    return_export9_dgram(priv_p, fib_export_p, item_p,
 477             struct netflow_v9_packet_opt *, int);
 478 int     export9_add(item_p, struct netflow_v9_packet_opt *, struct flow_entry *);
 479 int     export9_send(priv_p, fib_export_p, item_p, struct netflow_v9_packet_opt *,
 480             int);
 481
 482 #endif  /* _KERNEL */
 483 #endif  /* _NG_NETFLOW_H_ */