public.h
Go to the documentation of this file.
1 /*
2  ** public.h
3  ** fixbuf IPFIX Implementation Public Interface
4  **
5  ** ------------------------------------------------------------------------
6  ** Copyright (C) 2006-2016 Carnegie Mellon University. All Rights Reserved.
7  ** ------------------------------------------------------------------------
8  ** Authors: Brian Trammell, Dan Ruef
9  ** ------------------------------------------------------------------------
10  ** Use of the libfixbuf system and related source code is subject to the terms
11  ** of the following licenses:
12  **
13  ** GNU Lesser GPL (LGPL) Rights pursuant to Version 2.1, February 1999
14  ** Government Purpose License Rights (GPLR) pursuant to DFARS 252.227.7013
15  **
16  ** NO WARRANTY
17  **
18  ** ANY INFORMATION, MATERIALS, SERVICES, INTELLECTUAL PROPERTY OR OTHER
19  ** PROPERTY OR RIGHTS GRANTED OR PROVIDED BY CARNEGIE MELLON UNIVERSITY
20  ** PURSUANT TO THIS LICENSE (HEREINAFTER THE "DELIVERABLES") ARE ON AN
21  ** "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY
22  ** KIND, EITHER EXPRESS OR IMPLIED AS TO ANY MATTER INCLUDING, BUT NOT
23  ** LIMITED TO, WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE,
24  ** MERCHANTABILITY, INFORMATIONAL CONTENT, NONINFRINGEMENT, OR ERROR-FREE
25  ** OPERATION. CARNEGIE MELLON UNIVERSITY SHALL NOT BE LIABLE FOR INDIRECT,
26  ** SPECIAL OR CONSEQUENTIAL DAMAGES, SUCH AS LOSS OF PROFITS OR INABILITY
27  ** TO USE SAID INTELLECTUAL PROPERTY, UNDER THIS LICENSE, REGARDLESS OF
28  ** WHETHER SUCH PARTY WAS AWARE OF THE POSSIBILITY OF SUCH DAMAGES.
29  ** LICENSEE AGREES THAT IT WILL NOT MAKE ANY WARRANTY ON BEHALF OF
30  ** CARNEGIE MELLON UNIVERSITY, EXPRESS OR IMPLIED, TO ANY PERSON
31  ** CONCERNING THE APPLICATION OF OR THE RESULTS TO BE OBTAINED WITH THE
32  ** DELIVERABLES UNDER THIS LICENSE.
33  **
34  ** Licensee hereby agrees to defend, indemnify, and hold harmless Carnegie
35  ** Mellon University, its trustees, officers, employees, and agents from
36  ** all claims or demands made against them (and any related losses,
37  ** expenses, or attorney's fees) arising out of, or relating to Licensee's
38  ** and/or its sub licensees' negligent use or willful misuse of or
39  ** negligent conduct or willful misconduct regarding the Software,
40  ** facilities, or other rights or assistance granted by Carnegie Mellon
41  ** University under this License, including, but not limited to, any
42  ** claims of product liability, personal injury, death, damage to
43  ** property, or violation of any laws or regulations.
44  **
45  ** Carnegie Mellon University Software Engineering Institute authored
46  ** documents are sponsored by the U.S. Department of Defense under
47  ** Contract FA8721-05-C-0003. Carnegie Mellon University retains
48  ** copyrights in all material produced under this contract. The U.S.
49  ** Government retains a non-exclusive, royalty-free license to publish or
50  ** reproduce these documents, or allow others to do so, for U.S.
51  ** Government purposes only pursuant to the copyright license under the
52  ** contract clause at 252.227.7013.
53  **
54  ** ------------------------------------------------------------------------
55  */
56 
946 #ifndef _FB_PUBLIC_H_
947 #define _FB_PUBLIC_H_
948 #include <fixbuf/autoinc.h>
949 
950 #ifdef __cplusplus
951 extern "C" {
952 #endif
953 
954 
955 /*
956  * Version check macro
957  */
958 #define FIXBUF_CHECK_VERSION(major, minor, release) \
959  (FIXBUF_VERSION_MAJOR > (major) || \
960  (FIXBUF_VERSION_MAJOR == (major) && FIXBUF_VERSION_MINOR > (minor)) || \
961  (FIXBUF_VERSION_MAJOR == (major) && FIXBUF_VERSION_MINOR == (minor) && \
962  FIXBUF_VERSION_RELEASE >= (release)))
963 
964 /*
965  * Error Handling Definitions
966  */
967 
969 #define FB_ERROR_DOMAIN g_quark_from_string("fixbufError")
970 
971 #define FB_ERROR_TMPL 1
972 
976 #define FB_ERROR_EOM 2
977 
982 #define FB_ERROR_EOF 3
983 
987 #define FB_ERROR_IPFIX 4
988 
993 #define FB_ERROR_BUFSZ 5
994 
995 #define FB_ERROR_IMPL 6
996 
997 #define FB_ERROR_IO 7
998 
1002 #define FB_ERROR_NLREAD 8
1003 
1008 #define FB_ERROR_NLWRITE 9
1009 
1012 #define FB_ERROR_NOELEMENT 10
1013 
1016 #define FB_ERROR_CONN 11
1017 
1021 #define FB_ERROR_NETFLOWV9 12
1022 
1025 #define FB_ERROR_TRANSMISC 13
1026 
1029 #define FB_ERROR_SFLOW 14
1030 
1033 #define FB_ERROR_SETUP 15
1034 
1035 /*
1036  * Public Datatypes and Constants
1037  */
1038 
1039 struct fBuf_st;
1045 typedef struct fBuf_st fBuf_t;
1046 
1053 typedef struct fbVarfield_st {
1055  size_t len;
1062  uint8_t *buf;
1063 } fbVarfield_t;
1064 
1065 
1066 struct fbInfoModel_st;
1071 typedef struct fbInfoModel_st fbInfoModel_t;
1072 
1076 typedef struct fbInfoModelIter_st {
1084  guint index;
1086 
1092 #define FB_IE_INIT_FULL(_name_, _ent_, _num_, _len_, _flags_, _min_, _max_, _type_, _desc_)\
1093  { {(const struct fbInfoElement_st*)_name_}, 0, _ent_, _num_, _len_, _flags_, _min_, _max_, _type_, _desc_ }
1094 
1100 #define FB_IE_INIT(_name_, _ent_, _num_, _len_, _flags_) \
1101  FB_IE_INIT_FULL(_name_, _ent_, _num_, _len_, _flags_, 0, 0, 0, (char*)NULL)
1102 
1103 
1109 #define FB_IE_NULL FB_IE_INIT(NULL, 0, 0, 0, 0)
1110 
1116 #define FB_IE_SEMANTIC(flags) ((flags & 0x0000ff00) >> 8)
1117 
1123 #define FB_IE_UNITS(flags) ((flags & 0xFFFF0000) >> 16)
1124 
1129 #define FB_IE_F_NONE 0x00000000
1130 
1135 #define FB_IE_F_ENDIAN 0x00000001
1136 
1146 #define FB_IE_F_REVERSIBLE 0x00000040
1147 
1155 #define FB_IE_F_ALIEN 0x00000080
1156 
1161 #define FB_IE_QUANTITY 0x00000100
1162 
1168 #define FB_IE_TOTALCOUNTER 0x00000200
1169 
1174 #define FB_IE_DELTACOUNTER 0x00000300
1175 
1180 #define FB_IE_IDENTIFIER 0x00000400
1181 
1186 #define FB_IE_FLAGS 0x00000500
1187 
1193 #define FB_IE_LIST 0x00000600
1194 
1200 #define FB_IE_DEFAULT 0x00000000
1201 
1212 #define FB_UNITS_BITS 0x00010000
1213 
1218 #define FB_UNITS_OCTETS 0x00020000
1219 
1224 #define FB_UNITS_PACKETS 0x00030000
1225 
1230 #define FB_UNITS_FLOWS 0x00040000
1231 
1236 #define FB_UNITS_SECONDS 0x00050000
1237 
1242 #define FB_UNITS_MILLISECONDS 0x00060000
1243 
1248 #define FB_UNITS_MICROSECONDS 0x00070000
1249 
1254 #define FB_UNITS_NANOSECONDS 0x00080000
1255 
1260 #define FB_UNITS_WORDS 0x00090000
1261 
1266 #define FB_UNITS_MESSAGES 0x000A0000
1267 
1272 #define FB_UNITS_HOPS 0x000B0000
1273 
1278 #define FB_UNITS_ENTRIES 0x000C0000
1279 
1284 #define FB_UNITS_FRAMES 0x000D0000
1285 
1289 #define FB_IE_VARLEN 65535
1290 
1295 #define FB_IE_BASIC_LIST 291
1296 
1300 #define FB_IE_SUBTEMPLATE_LIST 292
1301 
1305 #define FB_IE_SUBTEMPLATE_MULTILIST 293
1306 
1314 #define FB_IE_PEN_REVERSE 29305
1315 
1324 #define FB_IE_VENDOR_BIT_REVERSE 0x4000
1325 
1331 #define FB_CISCO_GENERIC 9999
1332 
1339 #define FB_CISCO_ASA_EVENT_ID 9998
1340 
1349 #define FB_CISCO_ASA_EVENT_XTRA 9997
1350 
1355 #define FB_IE_REVERSE_STR "reverse"
1356 
1358 #define FB_IE_REVERSE_STRLEN 7
1359 
1366  FB_OCTET_ARRAY,
1367  FB_UINT_8,
1368  FB_UINT_16,
1369  FB_UINT_32,
1370  FB_UINT_64,
1371  FB_INT_8,
1372  FB_INT_16,
1373  FB_INT_32,
1374  FB_INT_64,
1375  FB_FLOAT_32,
1376  FB_FLOAT_64,
1377  FB_BOOL,
1378  FB_MAC_ADDR,
1379  FB_STRING,
1380  FB_DT_SEC,
1381  FB_DT_MILSEC,
1382  FB_DT_MICROSEC,
1383  FB_DT_NANOSEC,
1384  FB_IP4_ADDR,
1385  FB_IP6_ADDR,
1386  FB_BASIC_LIST,
1387  FB_SUB_TMPL_LIST,
1388  FB_SUB_TMPL_MULTI_LIST
1390 
1399 typedef struct fbInfoElement_st {
1401  union {
1407  const struct fbInfoElement_st *canon;
1412  const char *name;
1413  } ref;
1414 
1420  uint32_t midx;
1422  uint32_t ent;
1427  uint16_t num;
1429  uint16_t len;
1432  uint32_t flags;
1434  uint64_t min;
1436  uint64_t max;
1438  uint8_t type;
1440  const char *description;
1441 } fbInfoElement_t;
1442 
1449 typedef struct fbInfoElementOptRec_st {
1451  uint32_t ie_pen;
1453  uint16_t ie_id;
1455  uint8_t ie_type;
1457  uint8_t ie_semantic;
1459  uint16_t ie_units;
1461  uint8_t padding[6];
1463  uint64_t ie_range_begin;
1465  uint64_t ie_range_end;
1471 
1472 
1477 #define FB_TID_AUTO 0
1478 
1482 #define FB_TID_TS 2
1483 
1487 #define FB_TID_OTS 3
1488 
1492 #define FB_TID_MIN_DATA 256
1493 
1494 struct fbTemplate_st;
1501 
1507 #define FB_IESPEC_NULL { NULL, 0, 0 }
1508 
1514 typedef struct fbInfoElementSpec_st {
1516  char *name;
1521  uint16_t len_override;
1528  uint32_t flags;
1530 
1531 struct fbSession_st;
1538 typedef struct fbSession_st fbSession_t;
1539 
1541 typedef enum fbTransport_en {
1568 } fbTransport_t;
1569 
1574 typedef struct fbConnSpec_st {
1576  fbTransport_t transport;
1578  char *host;
1580  char *svc;
1593  void *vai;
1598  void *vssl_ctx;
1599 } fbConnSpec_t;
1600 
1604 #define FB_CONNSPEC_INIT { FB_SCTP, NULL, NULL, \
1605  NULL, NULL, NULL, NULL, \
1606  NULL, NULL }
1607 
1608 #if HAVE_SPREAD
1609 
1614 #define FB_SPREADPARAMS_INIT { 0, 0, 0 }
1615 
1616 typedef struct fbSpreadParams_st {
1619  fbSession_t * session;
1622  char * daemon;
1625  char ** groups;
1626 } fbSpreadParams_t;
1627 
1628 #endif /* HAVE_SPREAD */
1629 
1630 struct fbExporter_st;
1636 typedef struct fbExporter_st fbExporter_t;
1637 
1638 struct fbCollector_st;
1646 typedef struct fbCollector_st fbCollector_t;
1647 
1648 struct fbListener_st;
1655 typedef struct fbListener_st fbListener_t;
1656 
1661 
1666 {
1673 };
1674 
1679 
1686 {
1693 };
1694 
1695 struct fbListenerGroup_st;
1699 typedef struct fbListenerGroup_st fbListenerGroup_t;
1700 
1717 typedef void (*fbNewTemplateCallback_fn) (
1718  fbSession_t *session,
1719  uint16_t tid,
1720  fbTemplate_t *tmpl);
1721 
1729 typedef void (*fbTemplateCtxFree_fn)(
1730  void *ctx);
1731 
1741 typedef void (*fbTemplateCtxFree2_fn)(
1742  void *tmpl_ctx,
1743  void *app_ctx);
1744 
1745 
1772 typedef void (*fbTemplateCtxCallback_fn) (
1773  fbSession_t *session,
1774  uint16_t tid,
1775  fbTemplate_t *tmpl,
1776  void **ctx,
1777  fbTemplateCtxFree_fn *fn);
1778 
1803 typedef void (*fbTemplateCtxCallback2_fn) (
1804  fbSession_t *session,
1805  uint16_t tid,
1806  fbTemplate_t *tmpl,
1807  void *app_ctx,
1808  void **tmpl_ctx,
1809  fbTemplateCtxFree2_fn *fn);
1810 
1811 
1819 #define FB_LIST_SEM_UNDEFINED 0xFF
1820 
1823 #define FB_LIST_SEM_NONE_OF 0x00
1824 
1827 #define FB_LIST_SEM_EXACTLY_ONE_OF 0x01
1828 
1831 #define FB_LIST_SEM_ONE_OR_MORE_OF 0x02
1832 
1835 #define FB_LIST_SEM_ALL_OF 0x03
1836 
1839 #define FB_LIST_SEM_ORDERED 0x04
1840 
1847 gboolean fbListValidSemantic(
1848  uint8_t semantic);
1849 
1850 /****** BASICLIST FUNCTIONS AND STRUCTS *******/
1856 typedef struct fbBasicList_st {
1860  uint8_t *dataPtr;
1862  uint16_t numElements;
1864  uint16_t dataLength;
1866  uint8_t semantic;
1867 } fbBasicList_t;
1868 
1869 
1876  void);
1877 
1890 void* fbBasicListInit(
1891  fbBasicList_t *basicListPtr,
1892  uint8_t semantic,
1893  const fbInfoElement_t *infoElement,
1894  uint16_t numElements);
1895 
1911  fbBasicList_t *basicListPtr,
1912  uint8_t semantic,
1913  const fbInfoElement_t *infoElement,
1914  uint16_t numElements,
1915  uint16_t dataLength,
1916  uint8_t *dataPtr);
1917 
1931  fbBasicList_t *basicListPtr);
1932 
1933 
1941 uint8_t fbBasicListGetSemantic(
1942  fbBasicList_t *basicListPtr);
1943 
1953  fbBasicList_t *basicListPtr,
1954  uint8_t semantic);
1955 
1956 
1965  fbBasicList_t *basicListPtr);
1966 
1972 void* fbBasicListGetDataPtr(
1973  fbBasicList_t *basicListPtr);
1974 
1984  fbBasicList_t *basicListPtr,
1985  uint16_t bl_index);
1986 
1995 void* fbBasicListGetNextPtr(
1996  fbBasicList_t *basicListPtr,
1997  void *currentPtr);
1998 
2008 void* fbBasicListRealloc(
2009  fbBasicList_t *basicList,
2010  uint16_t newNumElements);
2011 
2020  fbBasicList_t *basicList,
2021  uint16_t numNewElements);
2022 
2028 void fbBasicListClear(
2029  fbBasicList_t *basicListPtr);
2030 
2038  fbBasicList_t *basicList);
2039 
2045 void fbBasicListFree(
2046  fbBasicList_t *basicListPtr);
2047 
2048 
2049 /******* END OF BASICLIST ********/
2050 
2051 
2052 
2053 /******* SUBTEMPLATELIST FUNCTIONS ****/
2054 
2062 typedef struct fbSubTemplateList_st {
2065  union {
2066  size_t length;
2067  uint64_t extra;
2068  } dataLength;
2072  uint8_t *dataPtr;
2074  uint16_t tmplID;
2076  uint16_t numElements;
2078  uint8_t semantic;
2080 
2088  void);
2089 
2102 void* fbSubTemplateListInit(
2103  fbSubTemplateList_t *sTL,
2104  uint8_t semantic,
2105  uint16_t tmplID,
2106  const fbTemplate_t *tmpl,
2107  uint16_t numElements);
2108 
2124  fbSubTemplateList_t *subTemplateList,
2125  uint8_t semantic,
2126  uint16_t tmplID,
2127  const fbTemplate_t *tmpl,
2128  uint16_t numElements,
2129  uint16_t dataLength,
2130  uint8_t *dataPtr);
2131 
2143  fbSubTemplateList_t *STL);
2144 
2151  const fbSubTemplateList_t *subTemplateListPtr);
2152 
2161  const fbSubTemplateList_t *subTemplateListPtr,
2162  uint16_t index);
2163 
2176  const fbSubTemplateList_t *subTemplateListPtr,
2177  void *currentPtr);
2178 
2186  fbSubTemplateList_t *subTemplateListPtr,
2187  uint8_t semantic);
2188 
2195  fbSubTemplateList_t *subTemplateListPtr);
2196 
2203  fbSubTemplateList_t *subTemplateListPtr);
2204 
2211  fbSubTemplateList_t *subTemplateListPtr);
2212 
2224  fbSubTemplateList_t *subTemplateList,
2225  uint16_t newNumElements);
2226 
2236  fbSubTemplateList_t *subTemplateList,
2237  uint16_t numNewElements);
2238 
2253  fbSubTemplateList_t *subTemplateListPtr);
2254 
2264  fbSubTemplateList_t *subTemplateListPtr);
2265 
2274  fbSubTemplateList_t *subTemplateListPtr);
2275 
2276 /********* END OF SUBTEMPLATELIST **********/
2298  uint8_t *dataPtr;
2300  size_t dataLength;
2302  uint16_t tmplID;
2304  uint16_t numElements;
2306 
2315  uint16_t numElements;
2317  uint8_t semantic;
2319 
2320 
2329  void);
2330 
2331 
2343  uint8_t semantic,
2344  uint16_t numElements);
2345 
2354  uint8_t semantic);
2355 
2362  fbSubTemplateMultiList_t *STML);
2363 
2371  fbSubTemplateMultiList_t *STML);
2372 
2383  fbSubTemplateMultiList_t *STML);
2384 
2391  fbSubTemplateMultiList_t *STML);
2392 
2404  uint16_t newNumEntries);
2405 
2416  uint16_t numNewEntries);
2417 
2424  fbSubTemplateMultiList_t *STML);
2425 
2435  uint16_t index);
2436 
2450  fbSubTemplateMultiListEntry_t *currentEntry);
2451 
2465  uint16_t tmplID,
2466  fbTemplate_t *tmpl,
2467  uint16_t numElements);
2468 
2481  uint16_t newNumElements);
2482 
2494  uint16_t numNewElements);
2495 
2504 
2513 
2527  void *currentPtr);
2528 
2541  uint16_t index);
2542 
2551 
2560 
2561 /************** END OF STML FUNCTIONS *********** */
2562 
2578 void fBufListFree(
2579  fbTemplate_t *tmpl,
2580  uint8_t *record);
2581 
2582 
2589  void);
2590 
2597 void fbListenerGroupFree(
2598  fbListenerGroup_t *group);
2599 
2610  fbListenerGroup_t *group,
2611  const fbListener_t *listener);
2612 
2623  fbListenerGroup_t *group,
2624  const fbListener_t *listener);
2625 
2637  fbListenerGroup_t *group,
2638  GError **err);
2639 
2640 
2648  fbListenerGroupResult_t *result);
2649 
2663  fbListener_t *listener,
2664  int sock,
2665  GError **err);
2666 
2677  fbListener_t *listener,
2678  int sock,
2679  GError **err);
2680 
2686 void fBufInterruptSocket(
2687  fBuf_t *fbuf);
2688 
2689 
2710 typedef gboolean (*fbListenerAppInit_fn) (
2711  fbListener_t *listener,
2712  void **ctx,
2713  int fd,
2714  struct sockaddr *peer,
2715  size_t peerlen,
2716  GError **err);
2717 
2725 typedef void (*fbListenerAppFree_fn) (
2726  void *ctx);
2727 
2728 /*
2729  * Public Function Calls. These calls will remain available and retain
2730  * their functionality in all subsequent versions of libfixbuf.
2731  */
2732 
2733 
2750 gboolean fBufSetInternalTemplate(
2751  fBuf_t *fbuf,
2752  uint16_t int_tid,
2753  GError **err);
2754 
2772 gboolean fBufSetExportTemplate(
2773  fBuf_t *fbuf,
2774  uint16_t ext_tid,
2775  GError **err);
2776 
2777 #if HAVE_SPREAD
2778 
2795 void fBufSetSpreadExportGroup(
2796  fBuf_t *fbuf,
2797  char **groups,
2798  int num_groups,
2799  GError **err);
2800 #endif
2801 
2817  fBuf_t *fbuf,
2818  gboolean automatic);
2819 
2834 gboolean fBufSetAutomaticInsert(
2835  fBuf_t *fbuf,
2836  GError **err);
2837 
2838 
2847  fBuf_t *fbuf);
2848 
2857 void fBufFree(
2858  fBuf_t *fbuf);
2859 
2873  fbSession_t *session,
2874  fbExporter_t *exporter);
2875 
2886  fBuf_t *fbuf);
2887 
2898 void fBufSetExporter(
2899  fBuf_t *fbuf,
2900  fbExporter_t *exporter);
2901 
2902 
2914 size_t fBufRemaining(
2915  fBuf_t *fbuf);
2916 
2917 
2930 void fBufSetBuffer(
2931  fBuf_t *fbuf,
2932  uint8_t *buf,
2933  size_t buflen);
2934 
2935 
2959 gboolean fBufAppend(
2960  fBuf_t *fbuf,
2961  uint8_t *recbase,
2962  size_t recsize,
2963  GError **err);
2964 
2974 gboolean fBufEmit(
2975  fBuf_t *fbuf,
2976  GError **err);
2977 
2989 void fBufSetExportTime(
2990  fBuf_t *fbuf,
2991  uint32_t extime);
2992 
3006  fbSession_t *session,
3007  fbCollector_t *collector);
3008 
3019  fBuf_t *fbuf);
3020 
3031 void fBufSetCollector(
3032  fBuf_t *fbuf,
3033  fbCollector_t *collector);
3034 
3064 gboolean fBufNext(
3065  fBuf_t *fbuf,
3066  uint8_t *recbase,
3067  size_t *recsize,
3068  GError **err);
3069 
3083 gboolean fBufNextMessage(
3084  fBuf_t *fbuf,
3085  GError **err);
3086 
3094 uint32_t fBufGetExportTime(
3095  fBuf_t *fbuf);
3096 
3117  fBuf_t *fbuf,
3118  uint16_t *ext_tid);
3119 
3139  fBuf_t *fbuf,
3140  uint16_t *ext_tid,
3141  GError **err);
3142 
3155 
3164 void fbInfoModelFree(
3165  fbInfoModel_t *model);
3166 
3182  fbInfoModel_t *model,
3183  fbInfoElement_t *ie);
3184 
3200  fbInfoModel_t *model,
3201  fbInfoElement_t *ie);
3202 
3215  fbInfoModel_t *model,
3216  const char *name);
3217 
3232  fbInfoModel_t *model,
3233  uint16_t id,
3234  uint32_t ent);
3235 
3244  const fbInfoModel_t *model);
3245 
3253 void fbInfoModelIterInit(
3254  fbInfoModelIter_t *iter,
3255  const fbInfoModel_t *model);
3256 
3268  fbInfoModelIter_t *iter);
3269 
3284  fbInfoModel_t *model,
3285  GError **err);
3286 
3301  fBuf_t *fbuf,
3302  const fbInfoElement_t *model_ie,
3303  uint16_t tid,
3304  GError **err);
3305 
3318  fbInfoModel_t *model,
3319  fbInfoElementOptRec_t *rec);
3320 
3330 gboolean fbInfoModelTypeInfoRecord(
3331  fbTemplate_t *tmpl);
3332 
3351  fbInfoModel_t *model);
3352 
3369 gboolean fbTemplateAppend(
3370  fbTemplate_t *tmpl,
3371  fbInfoElement_t *ex_ie,
3372  GError **err);
3373 
3389 gboolean fbTemplateAppendSpec(
3390  fbTemplate_t *tmpl,
3391  fbInfoElementSpec_t *spec,
3392  uint32_t flags,
3393  GError **err);
3394 
3412 gboolean fbTemplateAppendSpecArray(
3413  fbTemplate_t *tmpl,
3414  fbInfoElementSpec_t *spec,
3415  uint32_t flags,
3416  GError **err);
3417 
3425 uint32_t fbTemplateCountElements(
3426  fbTemplate_t *tmpl);
3427 
3438  fbTemplate_t *tmpl,
3439  uint16_t scope_count);
3440 
3448 uint32_t fbTemplateGetOptionsScope(
3449  fbTemplate_t *tmpl);
3450 
3462 gboolean fbTemplateContainsElement(
3463  fbTemplate_t *tmpl,
3464  const fbInfoElement_t *ex_ie);
3465 
3476  fbTemplate_t *tmpl,
3477  fbInfoElementSpec_t *spec);
3478 
3489  fbTemplate_t *tmpl,
3490  fbInfoElementSpec_t *spec);
3491 
3503  fbTemplate_t *tmpl,
3504  fbInfoElementSpec_t *spec,
3505  uint32_t flags);
3506 
3516  fbTemplate_t *tmpl,
3517  uint32_t IEindex);
3518 
3527  fbTemplate_t *tmpl);
3528 
3536 void *fbTemplateGetContext(
3537  fbTemplate_t *tmpl);
3538 
3557  fbInfoModel_t *model);
3558 
3569  fbSession_t *session,
3570  gboolean enabled,
3571  GError **err);
3572 
3582  fbSession_t *session,
3583  gboolean enabled,
3584  GError **err);
3585 
3602  fbSession_t *session,
3603  gboolean internal,
3604  uint16_t tid,
3605  fbTemplate_t *tmpl,
3606  const char *name,
3607  const char *description,
3608  GError **err);
3609 
3621  fbSession_t *session,
3622  uint16_t tid,
3623  const char *name,
3624  const char *description,
3625  GError **err);
3626 
3636  fbSession_t *session);
3637 
3638 
3663  fbSession_t *session,
3664  fbNewTemplateCallback_fn callback);
3665 
3704  fbSession_t *session,
3705  fbTemplateCtxCallback_fn callback);
3706 
3740  fbSession_t *session,
3741  fbTemplateCtxCallback2_fn callback,
3742  void *app_ctx);
3743 
3768  fbSession_t *session,
3769  uint16_t ent_tid,
3770  uint16_t int_tid);
3771 
3782  fbSession_t *session,
3783  uint16_t ext_tid);
3784 
3794  fbSession_t *session,
3795  uint16_t ext_tid);
3796 
3806 void fbSessionFree(
3807  fbSession_t *session);
3808 
3822  fbSession_t *session);
3823 
3839 void fbSessionSetDomain(
3840  fbSession_t *session,
3841  uint32_t domain);
3842 
3850 uint32_t fbSessionGetDomain(
3851  fbSession_t *session);
3852 
3861  fbSession_t *session);
3862 
3863 #if HAVE_SPREAD
3864 
3886 uint16_t fbSessionAddTemplatesMulticast(
3887  fbSession_t *session,
3888  char **groups,
3889  gboolean internal,
3890  uint16_t tid,
3891  fbTemplate_t *tmpl,
3892  GError **err);
3893 
3918 uint16_t fbSessionAddTemplatesMulticastWithMetadata(
3919  fbSession_t *session,
3920  char **groups,
3921  gboolean internal,
3922  uint16_t tid,
3923  fbTemplate_t *tmpl,
3924  char *name,
3925  char *description,
3926  GError **err);
3927 
3943 gboolean fbSessionSpreadEnableTemplateMetadata(
3944  fbSession_t *session,
3945  char **groups,
3946  gboolean enabled,
3947  GError **err);
3948 
3963 gboolean fbSessionSpreadEnableTypeMetadata(
3964  fbSession_t *session,
3965  char **groups,
3966  gboolean enabled,
3967  GError **err);
3968 
3969 #endif
3970 
3983 gboolean fbSessionExportTemplate(
3984  fbSession_t *session,
3985  uint16_t tid,
3986  GError **err);
3987 
3999 gboolean fbSessionExportTemplates(
4000  fbSession_t *session,
4001  GError **err);
4002 
4021 uint16_t fbSessionAddTemplate(
4022  fbSession_t *session,
4023  gboolean internal,
4024  uint16_t tid,
4025  fbTemplate_t *tmpl,
4026  GError **err);
4027 
4040 gboolean fbSessionRemoveTemplate(
4041  fbSession_t *session,
4042  gboolean internal,
4043  uint16_t tid,
4044  GError **err);
4045 
4058  fbSession_t *session,
4059  gboolean internal,
4060  uint16_t tid,
4061  GError **err);
4062 
4076  fbConnSpec_t *spec);
4077 
4078 #if HAVE_SPREAD
4079 
4090 int fbCollectorGetSpreadReturnGroups(
4091  fbCollector_t *collector,
4092  char *groups[]);
4093 
4107 fbExporter_t *fbExporterAllocSpread(
4108  fbSpreadParams_t *params );
4109 
4110 #endif /* HAVE_SPREAD */
4111 
4124  const char *path);
4125 
4136  uint8_t *buf,
4137  uint16_t bufsize);
4138 
4139 
4149  FILE *fp);
4150 
4163 void fbExporterSetStream(
4164  fbExporter_t *exporter,
4165  int sctp_stream);
4166 
4180  fbExporter_t *exporter);
4181 
4189 void fbExporterClose(
4190  fbExporter_t *exporter);
4191 
4198 size_t fbExporterGetMsgLen(
4199  fbExporter_t *exporter);
4200 
4214  void *ctx,
4215  const char *path,
4216  GError **err);
4217 
4229  void *ctx,
4230  FILE *fp);
4231 
4232 
4233 #if HAVE_SPREAD
4234 
4244 fbCollector_t *fbCollectorAllocSpread(
4245  void *ctx,
4246  fbSpreadParams_t *params,
4247  GError **err );
4248 
4249 #endif /* HAVE_SPREAD */
4250 
4261 void *fbCollectorGetContext(
4262  fbCollector_t *collector);
4263 
4274 void fbCollectorClose(
4275  fbCollector_t *collector);
4276 
4277 
4290  fbCollector_t *collector,
4291  struct sockaddr *address,
4292  size_t address_length);
4293 
4323  fbConnSpec_t *spec,
4324  fbSession_t *session,
4325  fbListenerAppInit_fn appinit,
4326  fbListenerAppFree_fn appfree,
4327  GError **err);
4328 
4336 void fbListenerFree(
4337  fbListener_t *listener);
4338 
4362  fbListener_t *listener,
4363  GError **err);
4364 
4376  fbListener_t *listener,
4377  GError **err);
4378 
4386 void fbListenerInterrupt(
4387  fbListener_t *listener);
4388 
4389 
4405 gboolean fbListenerGetCollector(
4406  fbListener_t *listener,
4407  fbCollector_t **collector,
4408  GError **err);
4409 
4410 
4411 
4412 
4429  fbCollector_t *collector,
4430  GError **err);
4431 
4432 
4449  fbCollector_t *collector,
4450  GError **err);
4451 
4452 
4469  fbCollector_t *collector,
4470  GError **err);
4471 
4493  fbCollector_t *collector,
4494  struct sockaddr *peer,
4495  size_t peerlen,
4496  uint32_t obdomain);
4497 
4515 uint32_t fbCollectorGetSFlowMissed(
4516  fbCollector_t *collector,
4517  struct sockaddr *peer,
4518  size_t peerlen,
4519  uint32_t obdomain);
4520 
4527 struct sockaddr* fbCollectorGetPeer(
4528  fbCollector_t *collector);
4529 
4540  fbCollector_t *collector);
4541 
4555  fbCollector_t *collector,
4556  gboolean multi_session);
4557 
4573  fbCollector_t *collector,
4574  gboolean manage_port);
4575 
4576 #ifdef __cplusplus
4577 } /* extern "C" */
4578 #endif
4579 
4580 #endif
fbInfoElement_t * fbTemplateGetIndexedIE(fbTemplate_t *tmpl, uint32_t IEindex)
Return the information element in the template referenced by the index.
uint32_t ent
Private Enterprise Number.
Definition: public.h:1422
struct fbSubTemplateMultiListEntry_st fbSubTemplateMultiListEntry_t
Entries contain the same type of information at SubTemplateLists: template ID and template pointers t...
fbExporter_t * fbExporterAllocFile(const char *path)
Allocate an exporting process endpoint for a named file.
fbListener_t * listener
pointer to the listener that received a new connection
Definition: public.h:1690
void fbTemplateFreeUnused(fbTemplate_t *tmpl)
Free a template if it is not currently in use by any Session.
char * ssl_ca_file
Path to certificate authority file.
Definition: public.h:1582
fbExporter_t * fbExporterAllocBuffer(uint8_t *buf, uint16_t bufsize)
Allocate an exporting process for a buffer.
void * vai
Pointer to address info cache.
Definition: public.h:1593
uint32_t ie_pen
private enterprise number
Definition: public.h:1451
A variable-length field value.
Definition: public.h:1053
void fbSubTemplateMultiListClearEntries(fbSubTemplateMultiList_t *STML)
Clears the memory used by the entries of a sub template multi list NOTE: if any of those entries cont...
void fbBasicListClearWithoutFree(fbBasicList_t *basicList)
Clear the parameters of the basic list, but do not free the buffer.
uint32_t fbTemplateGetOptionsScope(fbTemplate_t *tmpl)
Determine number of scope information elements in a template.
void * fbSubTemplateMultiListEntryAddNewElements(fbSubTemplateMultiListEntry_t *entry, uint16_t numNewElements)
Allocates space for a number of additional elements in the sub template multi list entry...
fbExporter_t * fbExporterAllocFP(FILE *fp)
Allocate an exporting process endpoint for an opened ANSI C file pointer.
gboolean fBufAppend(fBuf_t *fbuf, uint8_t *recbase, size_t recsize, GError **err)
Append a record to a buffer.
char * ssl_cert_file
Path to certificate file.
Definition: public.h:1584
Partially reliable datagram transport via SCTP.
Definition: public.h:1546
void fBufListFree(fbTemplate_t *tmpl, uint8_t *record)
Clear all of the memory that fixbuf allocated during transcode of this record.
uint64_t ie_range_begin
ie range min
Definition: public.h:1463
uint16_t numElements
number of elements in the list
Definition: public.h:2076
uint64_t min
range min
Definition: public.h:1434
uint64_t ie_range_end
ie range max
Definition: public.h:1465
void fbBasicListFree(fbBasicList_t *basicListPtr)
Clear the basic list, then free the basic list pointer.
const fbInfoElement_t * fbInfoModelGetElementByName(fbInfoModel_t *model, const char *name)
Return a pointer to the canonical information element within an information model given the informati...
void fbExporterClose(fbExporter_t *exporter)
Force the file or socket underlying an exporting process endpoint to close.
fBuf_t * fbuf
pointer to the fbuf created for that new connection
Definition: public.h:1692
gboolean fbSessionEnableTypeMetadata(fbSession_t *session, gboolean enabled, GError **err)
Configure a session to export type information for enterprise-specific information elements as option...
uint16_t tmplID
ID of the template used to structure the data in this entry.
Definition: public.h:2302
void * fbBasicListInitWithOwnBuffer(fbBasicList_t *basicListPtr, uint8_t semantic, const fbInfoElement_t *infoElement, uint16_t numElements, uint16_t dataLength, uint8_t *dataPtr)
use this function to initialize the basic list, but it gets the pointer to a buffer and its length al...
void fbSessionSetDomain(fbSession_t *session, uint32_t domain)
Set the current observation domain on a session.
fbCollector_t * fbSessionGetCollector(fbSession_t *session)
Retrieve collector that was created with the session.
const fbInfoElement_t * fbBasicListGetInfoElement(fbBasicList_t *basicListPtr)
This function returns a pointer to the information element used in the list it is mainly used in coll...
fBuf_t * fbListenerWait(fbListener_t *listener, GError **err)
Wait on a listener.
Multilists just contain the semantic to describe the sub lists, the number of sub lists...
Definition: public.h:2311
struct fbConnSpec_st fbConnSpec_t
Connection specifier.
void fBufSetAutomaticMode(fBuf_t *fbuf, gboolean automatic)
Set the automatic mode flag on a buffer.
void * fbSubTemplateMultiListEntryRealloc(fbSubTemplateMultiListEntry_t *entry, uint16_t newNumElements)
Frees the memory for the data used by the entry, then allocates a new buffer based on the size of the...
struct fbCollector_st fbCollector_t
IPFIX Collecting Process endpoint.
Definition: public.h:1646
struct fbExporter_st fbExporter_t
IPFIX Exporting Process endpoint.
Definition: public.h:1636
uint8_t semantic
value used to describe the contents of the list, all-of, one-of, etc
Definition: public.h:2078
fbSubTemplateMultiList_t * fbSubTemplateMultiListAlloc(void)
Allocates a subTemplateMultiList_t Based on how subTemplateMultiLists will be used and set up amidst ...
Secure, reliable stream transport via TLS over TCP.
Definition: public.h:1561
const fbTemplate_t * tmpl
pointer to the template used to structure the data
Definition: public.h:2070
void fbSubTemplateMultiListSetSemantic(fbSubTemplateMultiList_t *STML, uint8_t semantic)
Sets the semantic field for the multi list.
struct fbSession_st fbSession_t
An IPFIX Transport Session state container.
Definition: public.h:1538
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListInit(fbSubTemplateMultiList_t *STML, uint8_t semantic, uint16_t numElements)
Initializes the multi list with semantic, numbers of elements, and allocates memory to store numEleme...
size_t dataLength
length of the buffer used to hold the data in this entry
Definition: public.h:2300
void fbSessionRemoveTemplatePair(fbSession_t *session, uint16_t ext_tid)
remove a template pair from the list this is called by fixbuf when a template is revoked from the ses...
struct fbListenerGroup_st fbListenerGroup_t
Structure that holds the listeners that are added to the group.
Definition: public.h:1699
void * fbSubTemplateListInit(fbSubTemplateList_t *sTL, uint8_t semantic, uint16_t tmplID, const fbTemplate_t *tmpl, uint16_t numElements)
Initializes a subTemplateList structure and alloc&#39;s the dataPtr to get a buffer able to hold numEleme...
struct fbListener_st fbListener_t
IPFIX Collecting Process session listener.
Definition: public.h:1655
size_t len
Length of content in buffer.
Definition: public.h:1055
Unreliable datagram transport via UDP.
Definition: public.h:1550
uint16_t dataLength
length of the buffer used to store the elements in the list
Definition: public.h:1864
void fbSubTemplateListFree(fbSubTemplateList_t *subTemplateListPtr)
Frees and clears a subTemplateList struct.
void fbSubTemplateListClear(fbSubTemplateList_t *subTemplateListPtr)
Clears a subtemplate list struct, notably freeing the dataPtr and setting it to NULL.
uint32_t fbCollectorGetNetflowMissed(fbCollector_t *collector, struct sockaddr *peer, size_t peerlen, uint32_t obdomain)
fbCollectorGetNetflowMissed
gboolean fbTemplateAppendSpecArray(fbTemplate_t *tmpl, fbInfoElementSpec_t *spec, uint32_t flags, GError **err)
Append information elements described by a specifier array to a template.
uint8_t * dataPtr
pointer to the memory that stores the elements in the list
Definition: public.h:1860
uint16_t num
Information Element number.
Definition: public.h:1427
fbSubTemplateList_t * fbSubTemplateListAlloc(void)
Allocates a subTemplateList_t Based on how subTemplateLists will be used and set up amidst data struc...
gboolean fbCollectorSetNetflowV9Translator(fbCollector_t *collector, GError **err)
fbCollectorSetNetflowV9Translator
struct sockaddr * fbCollectorGetPeer(fbCollector_t *collector)
Retrieves information about the node connected to this collector.
uint16_t numElements
number of elements in the list
Definition: public.h:1862
gboolean fbTemplateAppend(fbTemplate_t *tmpl, fbInfoElement_t *ex_ie, GError **err)
Append an information element to a template.
gboolean fBufEmit(fBuf_t *fbuf, GError **err)
Emit the message currently in a buffer using the associated exporting process endpoint.
void(* fbTemplateCtxCallback_fn)(fbSession_t *session, uint16_t tid, fbTemplate_t *tmpl, void **ctx, fbTemplateCtxFree_fn *fn)
A callback function that will be called when the session receives a new external template.
Definition: public.h:1772
fbSubTemplateMultiListEntry_t * firstEntry
pointer to the first entry in the multi list
Definition: public.h:2313
struct fbInfoElement_st fbInfoElement_t
A single IPFIX Information Element definition.
struct fbBasicList_st fbBasicList_t
A basic list element in a template which structure represents a basic list on the internal side...
fbCollector_t * fbCollectorAllocFP(void *ctx, FILE *fp)
Allocate a collecting process endpoint for an open file.
void fbSessionAddTemplateCallback(fbSession_t *session, fbNewTemplateCallback_fn callback)
This function sets the callback to let the user know when a new template has arrived from the connect...
void fBufInterruptSocket(fBuf_t *fbuf)
Interrupts the select call of a specific collector by way of its fBuf.
uint16_t len
Information element length in octets.
Definition: public.h:1429
fbExporter_t * fbExporterAllocNet(fbConnSpec_t *spec)
Allocate an exporting process endpoint for a network connection.
void fBufSetCollector(fBuf_t *fbuf, fbCollector_t *collector)
Associate an collecting process endpoint with a buffer.
gboolean fbTemplateContainsAllElementsByName(fbTemplate_t *tmpl, fbInfoElementSpec_t *spec)
Determine if a template contains at least one instance of each information element in a given informa...
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListRealloc(fbSubTemplateMultiList_t *STML, uint16_t newNumEntries)
Clears the entries used by the multi list, then if newNumElements is different than numElements...
void fbSessionAddTemplatePair(fbSession_t *session, uint16_t ent_tid, uint16_t int_tid)
Adds an external-internal template pair to the session.
gboolean fBufNext(fBuf_t *fbuf, uint8_t *recbase, size_t *recsize, GError **err)
Retrieve a record from a buffer.
fBuf_t * fBufAllocForCollection(fbSession_t *session, fbCollector_t *collector)
Allocate a new buffer for collection.
gboolean fbTemplateContainsAllFlaggedElementsByName(fbTemplate_t *tmpl, fbInfoElementSpec_t *spec, uint32_t flags)
Determine if a template contains at least one instance of each information element in a given informa...
void * fbSubTemplateListGetDataPtr(const fbSubTemplateList_t *subTemplateListPtr)
Returns a pointer to the buffer that contains the data for the list.
void fBufFree(fBuf_t *fbuf)
Free a buffer.
gboolean fbSessionEnableTemplateMetadata(fbSession_t *session, gboolean enabled, GError **err)
Configure a session to export template metadata as options records.
void fbBasicListClear(fbBasicList_t *basicListPtr)
Clear the parameters of the basic list and free the data buffer.
const fbInfoElement_t * infoElement
pointer to the information element that is repeated in the list
Definition: public.h:1858
void * fbBasicListGetDataPtr(fbBasicList_t *basicListPtr)
void fbSubTemplateListCollectorInit(fbSubTemplateList_t *STL)
Initializes a sub template list variable on a collector.
void fbSubTemplateListClearWithoutFree(fbSubTemplateList_t *subTemplateListPtr)
Clears the sub template list parameters but does not free the data ptr.
void fBufSetBuffer(fBuf_t *fbuf, uint8_t *buf, size_t buflen)
Set a buffer on an fBuf for collection.
fbSession_t * fbSessionAlloc(fbInfoModel_t *model)
Allocate a transport session state container.
fBuf_t * fbListenerWaitNoCollectors(fbListener_t *listener, GError **err)
Waits for an incoming connection, just like fbListenerWait, except that this function doesn&#39;t monitor...
uint16_t fbSessionLookupTemplatePair(fbSession_t *session, uint16_t ext_tid)
Function to find a pair, uniquely identified by the external ID, and return the associated internal t...
struct fbInfoElementOptRec_st fbInfoElementOptRec_t
The corresponding struct to the Information Element Type Options Template.
uint32_t flags
Application flags word.
Definition: public.h:1528
void(* fbNewTemplateCallback_fn)(fbSession_t *session, uint16_t tid, fbTemplate_t *tmpl)
The callback function to be called when the session receives a new external template from the connect...
Definition: public.h:1717
fbExporter_t * fBufGetExporter(fBuf_t *fbuf)
Retrieve the exporting process endpoint associated with a buffer.
struct fbSubTemplateList_st fbSubTemplateList_t
Structure used to hold information of a sub template list.
uint8_t ie_type
ie data type
Definition: public.h:1455
fbTemplate_t * fbInfoElementAllocTypeTemplate(fbInfoModel_t *model, GError **err)
Allocate the Options Template that will be used to define Information Element Type Records...
uint16_t numElements
number of sub template lists in the multi list
Definition: public.h:2315
guint index
iterator index
Definition: public.h:1084
void fbSubTemplateMultiListFree(fbSubTemplateMultiList_t *STML)
Clears the multi list, then frees the memory pointed to by STML.
void fbSubTemplateMultiListClear(fbSubTemplateMultiList_t *STML)
Clears all of the entries (frees their data pointers), then frees the memory containing the entries...
struct fbInfoElementSpec_st fbInfoElementSpec_t
A single IPFIX Information Element specification.
ListenerEntry&#39;s make up a listener group as a linked list.
Definition: public.h:1665
fBuf_t * fBufAllocForExport(fbSession_t *session, fbExporter_t *exporter)
Allocate a new buffer for export.
gboolean fbTemplateContainsElement(fbTemplate_t *tmpl, const fbInfoElement_t *ex_ie)
Determine if a template contains a given information element.
void * fbSubTemplateMultiListEntryGetDataPtr(fbSubTemplateMultiListEntry_t *entry)
Retrieves the data pointer for this entry.
ListenerGroupResult&#39;s contain the listener who&#39;s listening socket got a new connection.
Definition: public.h:1685
fbListenerGroup_t * fbListenerGroupAlloc(void)
Allocates and returns a fbListenerGroup with no entries.
enum fbTransport_en fbTransport_t
Transport protocol for connection specifier.
uint8_t * dataPtr
pointer to the buffer used to hold the data
Definition: public.h:2072
fbInfoModel_t * fbInfoModelAlloc(void)
Allocate a new information model.
fbVarfield_t ie_name
information element name
Definition: public.h:1467
uint8_t semantic
value used to describe the list of sub templates
Definition: public.h:2317
void fbCollectorSetAcceptOnly(fbCollector_t *collector, struct sockaddr *address, size_t address_length)
Set the collector to only receive from the given IP address over UDP.
void(* fbTemplateCtxCallback2_fn)(fbSession_t *session, uint16_t tid, fbTemplate_t *tmpl, void *app_ctx, void **tmpl_ctx, fbTemplateCtxFree2_fn *fn)
A callback function that will be called when the session receives a new external template.
Definition: public.h:1803
uint8_t fbSubTemplateMultiListGetSemantic(fbSubTemplateMultiList_t *STML)
Get the semantic paramter from the multi list.
Structure used to hold information of a sub template list.
Definition: public.h:2062
char * name
Information element name.
Definition: public.h:1516
void * fbSubTemplateListGetNextPtr(const fbSubTemplateList_t *subTemplateListPtr, void *currentPtr)
This function also traverses the elements in the list by accepting a pointer to the last element the ...
void fBufSetExportTime(fBuf_t *fbuf, uint32_t extime)
Set the export time on the message currently in a buffer.
void * vssl_ctx
Pointer to SSL context cache.
Definition: public.h:1598
uint32_t midx
Multiple IE index.
Definition: public.h:1420
size_t fbExporterGetMsgLen(fbExporter_t *exporter)
Get the (transcoded) message length that was copied to the exporting buffer upon fBufEmit().
void * fbBasicListGetNextPtr(fbBasicList_t *basicListPtr, void *currentPtr)
Function returns the next element in the list based on the currentPtr.
fbListenerEntry_t * prev
pointer to the previous listener entry in the linked list
Definition: public.h:1670
char * host
Hostname to connect/listen to.
Definition: public.h:1578
An iterator over the information elements in an information model.
Definition: public.h:1076
gboolean fbSessionExportTemplates(fbSession_t *session, GError **err)
Export all external templates in the current domain of a given session.
fbTemplate_t * fBufNextCollectionTemplate(fBuf_t *fbuf, uint16_t *ext_tid, GError **err)
Retrieve the external template that will be used to read the next record from the buffer...
gboolean fbSessionSetTemplateMetadata(fbSession_t *session, uint16_t tid, const char *name, const char *description, GError **err)
Add template metadata for a given template.
uint32_t fbCollectorGetSFlowMissed(fbCollector_t *collector, struct sockaddr *peer, size_t peerlen, uint32_t obdomain)
fbCollectorGetSFlowMissed
void fbInfoModelFree(fbInfoModel_t *model)
Free an information model.
uint16_t tmplID
ID of the template used to structure the data.
Definition: public.h:2074
void fbSubTemplateListSetSemantic(fbSubTemplateList_t *subTemplateListPtr, uint8_t semantic)
Sets the semantic parameter of a subTemplateList.
const struct fbInfoElement_st * canon
Pointer to canonical copy of IE.
Definition: public.h:1407
fbTemplate_t * fBufGetCollectionTemplate(fBuf_t *fbuf, uint16_t *ext_tid)
Retrieve the external template used to read the last record from the buffer.
fbCollector_t * fBufGetCollector(fBuf_t *fbuf)
Retrieve the collecting process endpoint associated with a buffer.
gboolean fbInfoElementWriteOptionsRecord(fBuf_t *fbuf, const fbInfoElement_t *model_ie, uint16_t tid, GError **err)
Export an options record to the given fbuf with information element type information about the given ...
void * fbCollectorGetContext(fbCollector_t *collector)
Retrieve the application context associated with a collector.
The corresponding struct to the Information Element Type Options Template.
Definition: public.h:1449
gboolean fBufSetExportTemplate(fBuf_t *fbuf, uint16_t ext_tid, GError **err)
Set the external template for export on a buffer to the given template ID.
void * fbBasicListRealloc(fbBasicList_t *basicList, uint16_t newNumElements)
Free the current data pointer, allocating a new buffer to accomodate the new number of elements...
Secure, unreliable datagram transport via DTLS over UDP.
Definition: public.h:1567
void fbExporterSetStream(fbExporter_t *exporter, int sctp_stream)
Set the SCTP stream for the next message exported.
void * fbSubTemplateMultiListEntryNextDataPtr(fbSubTemplateMultiListEntry_t *entry, void *currentPtr)
This function traverses the elements in the entry by accepting a pointer to the last element the user...
struct fbInfoModel_st fbInfoModel_t
An IPFIX information model.
Definition: public.h:1071
void * fbSubTemplateMultiListEntryGetIndexedPtr(fbSubTemplateMultiListEntry_t *entry, uint16_t index)
Returns a pointer to a data element in the entry based on the index.
uint32_t flags
Flags.
Definition: public.h:1432
gboolean fbInfoElementAddOptRecElement(fbInfoModel_t *model, fbInfoElementOptRec_t *rec)
Add an element that we received via an Options Record to the given info model.
const char * description
description
Definition: public.h:1440
uint16_t numElements
number of elements in this entry
Definition: public.h:2304
gboolean fbTemplateContainsElementByName(fbTemplate_t *tmpl, fbInfoElementSpec_t *spec)
Determine if a template contains at least one instance of a given information element, specified by name in the template&#39;s information model.
Reliable stream transport via TCP.
Definition: public.h:1548
void fbInfoModelAddElement(fbInfoModel_t *model, fbInfoElement_t *ie)
Add a single information element to an information model.
uint32_t fbSessionGetDomain(fbSession_t *session)
Retrieve the current domain on a session.
void * fbBasicListAddNewElements(fbBasicList_t *basicList, uint16_t numNewElements)
Allocates an additional elememnt into the basic list must be called after calling BasicListInit...
Entries contain the same type of information at SubTemplateLists: template ID and template pointers t...
Definition: public.h:2294
gboolean(* fbListenerAppInit_fn)(fbListener_t *listener, void **ctx, int fd, struct sockaddr *peer, size_t peerlen, GError **err)
Application context initialization function type for fbListener_t.
Definition: public.h:2710
fbVarfield_t ie_desc
information element description
Definition: public.h:1469
void * fbBasicListInit(fbBasicList_t *basicListPtr, uint8_t semantic, const fbInfoElement_t *infoElement, uint16_t numElements)
Initializes the basic list structure based on the parameters.
int fbListenerGroupAddListener(fbListenerGroup_t *group, const fbListener_t *listener)
Adds a previously allocated listener to the previously allocated group.
gboolean fbInfoModelTypeInfoRecord(fbTemplate_t *tmpl)
Checks to see if the template contains all of the elements the RFC 5610 info element type record shou...
gboolean fBufSetAutomaticInsert(fBuf_t *fbuf, GError **err)
Set the automatic insert flag on a buffer.
void fbExporterAutoStream(fbExporter_t *exporter)
Enable automatic SCTP stream selection for the next message exported.
struct fbVarfield_st fbVarfield_t
A variable-length field value.
fbInfoModel_t * fbSessionGetInfoModel(fbSession_t *session)
fbSessionGetInfoModel
guint fbInfoModelCountElements(const fbInfoModel_t *model)
Return the number of information elements in the information model.
enum fbInfoElementDataType_en fbInfoElementDataType_t
From RFC 5610: A description of the abstract data type of an IPFIX information element as registered ...
union fbInfoElement_st::@1 ref
Information element name.
fbTransport_t transport
Transport protocol to use.
Definition: public.h:1576
void fbSubTemplateMultiListEntryClear(fbSubTemplateMultiListEntry_t *entry)
Frees the memory pointed to by the data buffer holding the data elements.
const fbTemplate_t * fbSubTemplateMultiListEntryGetTemplate(fbSubTemplateMultiListEntry_t *entry)
Retrieve the template pointer used to structure the data elements.
struct fbInfoModelIter_st fbInfoModelIter_t
An iterator over the information elements in an information model.
char * svc
Service name or port number to connect/listen to.
Definition: public.h:1580
void fbCollectorSetUDPMultiSession(fbCollector_t *collector, gboolean multi_session)
Attempt to maintain backwards compatibility with UDP.
void fbSessionAddTemplateCtxCallback(fbSession_t *session, fbTemplateCtxCallback_fn callback)
This function sets the callback that allows the application to set its own context variable with a ne...
uint8_t * dataPtr
pointer to the buffer used to hold the data in this entry
Definition: public.h:2298
void fbCollectorManageUDPStreamByPort(fbCollector_t *collector, gboolean manage_port)
An attempt to fix what some netflow v9 exporters do wrong.
fbListener_t * fbListenerAlloc(fbConnSpec_t *spec, fbSession_t *session, fbListenerAppInit_fn appinit, fbListenerAppFree_fn appfree, GError **err)
Allocate a listener.
const fbInfoElement_t * fbInfoModelGetElementByID(fbInfoModel_t *model, uint16_t id, uint32_t ent)
Return a pointer to the canonical information element within an information model given the informati...
char * ssl_key_pass
Private key decryption password.
Definition: public.h:1588
void fbSessionAddTemplateCtxCallback2(fbSession_t *session, fbTemplateCtxCallback2_fn callback, void *app_ctx)
This function sets the callback that allows the application to set its own context variable with a ne...
uint16_t ie_id
information element id
Definition: public.h:1453
gboolean fBufNextMessage(fBuf_t *fbuf, GError **err)
Read a new message into a buffer using the associated collecting process endpoint.
void * fbSubTemplateListGetIndexedDataPtr(const fbSubTemplateList_t *subTemplateListPtr, uint16_t index)
This function is used to iterate over the elements in the list by passing in a counter to indicate wh...
void * fbBasicListGetIndexedDataPtr(fbBasicList_t *basicListPtr, uint16_t bl_index)
Function retrieves the index&#39;th element in the list index is 0-based.
fbInfoElementDataType_en
From RFC 5610: A description of the abstract data type of an IPFIX information element as registered ...
Definition: public.h:1365
const fbInfoModel_t * model
information Model
Definition: public.h:1080
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListGetNextEntry(fbSubTemplateMultiList_t *STML, fbSubTemplateMultiListEntry_t *currentEntry)
This function also traverses the elements in the list by accepting a pointer to the last element the ...
uint32_t fBufGetExportTime(fBuf_t *fbuf)
Retrieve the export time on the message currently in a buffer.
void * fbSubTemplateListInitWithOwnBuffer(fbSubTemplateList_t *subTemplateList, uint8_t semantic, uint16_t tmplID, const fbTemplate_t *tmpl, uint16_t numElements, uint16_t dataLength, uint8_t *dataPtr)
Initializes the subTemplateList but does not allocate a buffer.
uint8_t * buf
Content buffer.
Definition: public.h:1062
fbListenerGroupResult_t * fbListenerGroupWait(fbListenerGroup_t *group, GError **err)
Similar to fbListenerWait, except that is looks for connections for multiple listeners.
uint16_t fbSubTemplateListGetTemplateID(fbSubTemplateList_t *subTemplateListPtr)
Gets the template ID for the template used by the list.
fbBasicList_t * fbBasicListAlloc(void)
allocates a Basic List Structure
fbTransport_en
Transport protocol for connection specifier.
Definition: public.h:1541
const fbInfoElement_t * fbInfoModelIterNext(fbInfoModelIter_t *iter)
Return a pointer to the next information element in the information model.
void * fbSubTemplateListRealloc(fbSubTemplateList_t *subTemplateList, uint16_t newNumElements)
Free the current data pointer, allocating a new buffer to accomodate the new number of elements...
void fBufSetExporter(fBuf_t *fbuf, fbExporter_t *exporter)
Associate an exporting process endpoint with a buffer.
An IPFIX template or options template structure.
Definition: private.h:207
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListGetFirstEntry(fbSubTemplateMultiList_t *STML)
Retrieve the first entry in the multi list.
void(* fbListenerAppFree_fn)(void *ctx)
Application context free function type for fbListener_t.
Definition: public.h:2725
void * fbTemplateGetContext(fbTemplate_t *tmpl)
Get the ctx pointer associated with a Template.
fbListenerEntry_t * next
pointer to the next listener entry in the linked list
Definition: public.h:1668
fbTemplate_t * fbTemplateAlloc(fbInfoModel_t *model)
Allocate a new empty template.
fbCollector_t * fbCollectorAllocFile(void *ctx, const char *path, GError **err)
Allocate a collecting process endpoint for a named file.
struct fbSubTemplateMultiList_st fbSubTemplateMultiList_t
Multilists just contain the semantic to describe the sub lists, the number of sub lists...
fbSession_t * fBufGetSession(fBuf_t *fbuf)
Retrieve the session associated with a buffer.
uint16_t ie_units
ie units
Definition: public.h:1459
void fbBasicListCollectorInit(fbBasicList_t *basicListPtr)
This initializes a basic list structure for collection.
fbListenerGroupResult_t * next
Pointer to the next listener group result.
Definition: public.h:1688
void fbListenerFreeGroupResult(fbListenerGroupResult_t *result)
Free the fbListenerGroupResult_t returned from fbListenerGroupWait.
Secure, partially reliable datagram transport via DTLS over SCTP.
Definition: public.h:1556
void(* fbTemplateCtxFree_fn)(void *ctx)
A callback function that is called when a template is freed.
Definition: public.h:1729
uint32_t fbTemplateCountElements(fbTemplate_t *tmpl)
Determine number of information elements in a template.
uint16_t fbSessionAddTemplateWithMetadata(fbSession_t *session, gboolean internal, uint16_t tid, fbTemplate_t *tmpl, const char *name, const char *description, GError **err)
Add a template to the session with the provided metadata.
uint32_t fbCollectorGetObservationDomain(fbCollector_t *collector)
Retrieves the observation domain of the node connected to the UDP collector.
size_t fBufRemaining(fBuf_t *fbuf)
Retrieve the length of the buffer that is remaining after processing.
void fbCollectorClose(fbCollector_t *collector)
Close the file or socket underlying a collecting process endpoint.
A basic list element in a template which structure represents a basic list on the internal side...
Definition: public.h:1856
void fbListenerGroupFree(fbListenerGroup_t *group)
frees a listener group
fBuf_t * fbListenerOwnSocketCollectorTCP(fbListener_t *listener, int sock, GError **err)
Returns an fBuf wrapped around an independently managed socket and a properly created listener for TC...
uint8_t fbBasicListGetSemantic(fbBasicList_t *basicListPtr)
Get Semantic field for Basic List presumably used in collectors after decoding.
Connection specifier.
Definition: public.h:1574
fbListener_t * listener
pointer to the listener to add to the list
Definition: public.h:1672
fbTemplate_t * tmpl
pointer to the template used to structure the data in this entry
Definition: public.h:2296
struct fBuf_st fBuf_t
An IPFIX message buffer.
Definition: public.h:1045
uint64_t max
range max
Definition: public.h:1436
fbTemplate_t * fbSessionGetTemplate(fbSession_t *session, gboolean internal, uint16_t tid, GError **err)
Retrieve a template from a session by ID.
uint16_t len_override
Length override; if nonzero, replace the length of the IE from the model with this length...
Definition: public.h:1521
gboolean fbSessionExportTemplate(fbSession_t *session, uint16_t tid, GError **err)
Export a single external template in the current domain of a given session.
uint16_t fbSessionAddTemplate(fbSession_t *session, gboolean internal, uint16_t tid, fbTemplate_t *tmpl, GError **err)
Add a template to a session.
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListAddNewEntries(fbSubTemplateMultiList_t *STML, uint16_t numNewEntries)
Adds entries to the multi list of entries can only be run after the list has been initialized...
void * fbSubTemplateListAddNewElements(fbSubTemplateList_t *subTemplateList, uint16_t numNewElements)
Allocates space for a number of additional element in the sub template list must be called after the ...
uint8_t fbSubTemplateListGetSemantic(fbSubTemplateList_t *subTemplateListPtr)
Gets the semantic value from a sub template list.
gboolean fbTemplateAppendSpec(fbTemplate_t *tmpl, fbInfoElementSpec_t *spec, uint32_t flags, GError **err)
Append an information element described by specifier to a template.
A single IPFIX Information Element definition.
Definition: public.h:1399
int fbListenerGroupDeleteListener(fbListenerGroup_t *group, const fbListener_t *listener)
Removes the listener from the group.
void(* fbTemplateCtxFree2_fn)(void *tmpl_ctx, void *app_ctx)
A callback function that is called when a template is freed.
Definition: public.h:1741
gboolean fbSessionRemoveTemplate(fbSession_t *session, gboolean internal, uint16_t tid, GError **err)
Remove a template from a session.
uint8_t semantic
semantic field to describe the list
Definition: public.h:1866
const char * name
Information element name.
Definition: public.h:1412
const fbTemplate_t * fbSubTemplateListGetTemplate(fbSubTemplateList_t *subTemplateListPtr)
Gets the template pointer from the list structure.
void fbInfoModelIterInit(fbInfoModelIter_t *iter, const fbInfoModel_t *model)
Initialize an information model iterator for iteration.
void fbSessionResetExternal(fbSession_t *session)
Reset the external state (sequence numbers and templates) in a session state container.
uint8_t type
Data Type.
Definition: public.h:1438
uint16_t fbSubTemplateMultiListEntryGetTemplateID(fbSubTemplateMultiListEntry_t *entry)
Retrieve the template ID for the template used to structure the data.
gboolean fbListenerGetCollector(fbListener_t *listener, fbCollector_t **collector, GError **err)
fbListenerGetCollector
gboolean fbCollectorSetSFlowTranslator(fbCollector_t *collector, GError **err)
fbCollectorSetSFlowTranslator
A single IPFIX Information Element specification.
Definition: public.h:1514
void fbListenerInterrupt(fbListener_t *listener)
Cause the current or next call to fbListenerWait to unblock and return.
fBuf_t * fbListenerOwnSocketCollectorTLS(fbListener_t *listener, int sock, GError **err)
Same as fbListenerOwnSocketCollectorTCP but for TLS (not tested)
fbSubTemplateMultiListEntry_t * fbSubTemplateMultiListGetIndexedEntry(fbSubTemplateMultiList_t *STML, uint16_t index)
Retrieve a pointer to the entry of a specific index.
gboolean fbCollectorClearTranslator(fbCollector_t *collector, GError **err)
fbCollectorClearTranslator
char * ssl_key_file
Path to private key file.
Definition: public.h:1586
void fbInfoModelAddElementArray(fbInfoModel_t *model, fbInfoElement_t *ie)
Add multiple information elements in an array to an information model.
void fbBasicListSetSemantic(fbBasicList_t *basicListPtr, uint8_t semantic)
Sets the semantic for describing a basic list generally used in exporters before decoding.
gboolean fBufSetInternalTemplate(fBuf_t *fbuf, uint16_t int_tid, GError **err)
Set the internal template on a buffer to the given template ID.
uint8_t ie_semantic
ie semantic
Definition: public.h:1457
void * fbSubTemplateMultiListEntryInit(fbSubTemplateMultiListEntry_t *entry, uint16_t tmplID, fbTemplate_t *tmpl, uint16_t numElements)
Initializes the multi list entry with the template values, and allocates the memory used by the entry...
void fbListenerFree(fbListener_t *listener)
Free a listener.
gboolean fbListValidSemantic(uint8_t semantic)
validates the value of the semantic field,
void fbSessionFree(fbSession_t *session)
Free a transport session state container.
void fbTemplateSetOptionsScope(fbTemplate_t *tmpl, uint16_t scope_count)
Set the number of information elements in a template that are scope.