Conntrack

Macros
#define	NFNLMSG_CT_TYPE(type)   NFNLMSG_TYPE(NFNL_SUBSYS_CTNETLINK, (type))

Functions
int	nfnlmsg_ct_group (struct nlmsghdr *nlh)
struct nfnl_ct *	nfnlmsg_ct_parse (struct nlmsghdr *nlh)
int	nfnl_ct_dump_request (struct nl_handle *h)

Cache Management
struct nl_cache *	nfnl_ct_alloc_cache (struct nl_handle *handle)
	Build a conntrack cache holding all conntrack currently in the kernel.

Detailed Description

Macro Definition Documentation

NFNLMSG_CT_TYPE

#define NFNLMSG_CT_TYPE

(

type

)

NFNLMSG_TYPE(NFNL_SUBSYS_CTNETLINK, (type))

Definition at line 439 of file ct.c.

Function Documentation

nfnlmsg_ct_group()

int nfnlmsg_ct_group

(

struct nlmsghdr *

nlh

)

Definition at line 274 of file ct.c.

{
        switch (nfnlmsg_subtype(nlh)) {
        case IPCTNL_MSG_CT_NEW:
                if (nlh->nlmsg_flags & (NLM_F_CREATE|NLM_F_EXCL))
                        return NFNLGRP_CONNTRACK_NEW;
                else
                        return NFNLGRP_CONNTRACK_UPDATE;
        case IPCTNL_MSG_CT_DELETE:
                return NFNLGRP_CONNTRACK_DESTROY;
        default:
                return NFNLGRP_NONE;
        }
}

nfnlmsg_ct_parse()

struct nfnl_ct * nfnlmsg_ct_parse

(

struct nlmsghdr *

nlh

)

Definition at line 289 of file ct.c.

{
        struct nfnl_ct *ct;
        struct nlattr *tb[CTA_MAX+1];
        int err;
 
        ct = nfnl_ct_alloc();
        if (!ct)
                return NULL;
 
        ct->ce_msgtype = nlh->nlmsg_type;
 
        err = nlmsg_parse(nlh, sizeof(struct nfgenmsg), tb, CTA_MAX,
                          ct_policy);
        if (err < 0)
                goto errout;
 
        nfnl_ct_set_family(ct, nfnlmsg_family(nlh));
 
        if (tb[CTA_TUPLE_ORIG]) {
                err = ct_parse_tuple(ct, 0, tb[CTA_TUPLE_ORIG]);
                if (err < 0)
                        goto errout;
        }
        if (tb[CTA_TUPLE_REPLY]) {
                err = ct_parse_tuple(ct, 1, tb[CTA_TUPLE_REPLY]);
                if (err < 0)
                        goto errout;
        }
 
        if (tb[CTA_PROTOINFO]) {
                err = ct_parse_protoinfo(ct, tb[CTA_PROTOINFO]);
                if (err < 0)
                        goto errout;
        }
 
        if (tb[CTA_STATUS])
                nfnl_ct_set_status(ct, ntohl(nla_get_u32(tb[CTA_STATUS])));
        if (tb[CTA_TIMEOUT])
                nfnl_ct_set_timeout(ct, ntohl(nla_get_u32(tb[CTA_TIMEOUT])));
        if (tb[CTA_MARK])
                nfnl_ct_set_mark(ct, ntohl(nla_get_u32(tb[CTA_MARK])));
        if (tb[CTA_USE])
                nfnl_ct_set_use(ct, ntohl(nla_get_u32(tb[CTA_USE])));
        if (tb[CTA_ID])
                nfnl_ct_set_id(ct, ntohl(nla_get_u32(tb[CTA_ID])));
 
        if (tb[CTA_COUNTERS_ORIG]) {
                err = ct_parse_counters(ct, 0, tb[CTA_COUNTERS_ORIG]);
                if (err < 0)
                        goto errout;
        }
 
        if (tb[CTA_COUNTERS_REPLY]) {
                err = ct_parse_counters(ct, 1, tb[CTA_COUNTERS_REPLY]);
                if (err < 0)
                        goto errout;
        }
 
        return ct;
 
errout:
        nfnl_ct_put(ct);
        return NULL;
}

nfnl_ct_dump_request()

int nfnl_ct_dump_request

(

struct nl_handle *

h

)

Definition at line 380 of file ct.c.

{
        return nfnl_send_simple(h, NFNL_SUBSYS_CTNETLINK, IPCTNL_MSG_CT_GET,
                                NLM_F_DUMP, AF_UNSPEC, 0);
}

nfnl_ct_alloc_cache()

struct nl_cache * nfnl_ct_alloc_cache

(

struct nl_handle *

handle

)

Parameters

handle

netlink handle

Allocates a new cache, initializes it properly and updates it to contain all conntracks currently in the kernel.

Note

The caller is responsible for destroying and freeing the cache after using it.

Returns

The cache or NULL if an error has occured.

Definition at line 407 of file ct.c.

{
        struct nl_cache *cache;
 
        cache = nl_cache_alloc(&nfnl_ct_ops);
        if (!cache)
                return NULL;
 
        if (handle && nl_cache_refill(handle, cache) < 0) {
                free(cache);
                return NULL;
        }
 
        return cache;
}

References nl_cache_alloc(), and nl_cache_refill().