expect/parse.c

/*
 * (C) 2005-2011 by Pablo Neira Ayuso <pablo@netfilter.org>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include "internal/internal.h"

int __parse_expect_message_type(const struct nlmsghdr *nlh)
{
        uint16_t type = NFNL_MSG_TYPE(nlh->nlmsg_type);
        uint16_t flags = nlh->nlmsg_flags;
        int ret = NFCT_T_UNKNOWN;

        if (type == IPCTNL_MSG_EXP_NEW) {
                if (flags & (NLM_F_CREATE|NLM_F_EXCL))
                        ret = NFCT_T_NEW;
                else
                        ret = NFCT_T_UPDATE;
        } else if (type == IPCTNL_MSG_EXP_DELETE)
                ret = NFCT_T_DESTROY;

        return ret;
}

void __parse_expect(const struct nlmsghdr *nlh,
                    struct nfattr *cda[],
                    struct nf_expect *exp)
{
        struct nfgenmsg *nfhdr = NLMSG_DATA(nlh);

        /* XXX: this is ugly, clean it up, please */
        exp->expected.orig.l3protonum = nfhdr->nfgen_family;
        set_bit(ATTR_ORIG_L3PROTO, exp->expected.set);

        exp->mask.orig.l3protonum = nfhdr->nfgen_family;
        set_bit(ATTR_ORIG_L3PROTO, exp->mask.set);

        exp->master.orig.l3protonum = nfhdr->nfgen_family;
        set_bit(ATTR_ORIG_L3PROTO, exp->master.set);

        if (cda[CTA_EXPECT_MASTER-1]) {
                __parse_tuple(cda[CTA_EXPECT_MASTER-1], 
                              &exp->master.orig,
                              __DIR_ORIG,
                              exp->master.set);
                set_bit(ATTR_EXP_MASTER, exp->set);
        }
        if (cda[CTA_EXPECT_TUPLE-1]) {
                __parse_tuple(cda[CTA_EXPECT_TUPLE-1], 
                              &exp->expected.orig,
                              __DIR_ORIG,
                              exp->expected.set);
                set_bit(ATTR_EXP_EXPECTED, exp->set);
        }
        if (cda[CTA_EXPECT_MASK-1]) {
                __parse_tuple(cda[CTA_EXPECT_MASK-1], 
                              &exp->mask.orig,
                              __DIR_ORIG,
                              exp->mask.set);
                set_bit(ATTR_EXP_MASK, exp->set);
        }
        if (cda[CTA_EXPECT_TIMEOUT-1]) {
                exp->timeout = 
                      ntohl(*(uint32_t *)NFA_DATA(cda[CTA_EXPECT_TIMEOUT-1]));
                set_bit(ATTR_EXP_TIMEOUT, exp->set);
        }

        if (cda[CTA_EXPECT_ZONE-1]) {
                exp->zone =
                      ntohs(*(uint16_t *)NFA_DATA(cda[CTA_EXPECT_ZONE-1]));
                set_bit(ATTR_EXP_ZONE, exp->set);
        }
        if (cda[CTA_EXPECT_FLAGS-1]) {
                exp->flags =
                      ntohl(*(uint32_t *)NFA_DATA(cda[CTA_EXPECT_FLAGS-1]));
                set_bit(ATTR_EXP_FLAGS, exp->set);
        }
        if (cda[CTA_EXPECT_HELP_NAME-1]) {
                strncpy(exp->helper_name, NFA_DATA(cda[CTA_EXPECT_HELP_NAME-1]),
                        NFA_PAYLOAD(cda[CTA_EXPECT_HELP_NAME-1]));
                set_bit(ATTR_EXP_HELPER_NAME, exp->set);
        }
        if (cda[CTA_EXPECT_CLASS-1]) {
                exp->class =
                      ntohl(*(uint32_t *)NFA_DATA(cda[CTA_EXPECT_CLASS-1]));
                set_bit(ATTR_EXP_CLASS, exp->set);
        }
        if (cda[CTA_EXPECT_NAT-1]) {
                struct nfattr *tb[CTA_EXPECT_NAT_MAX];

                exp->nat.orig.l3protonum = nfhdr->nfgen_family;
                set_bit(ATTR_ORIG_L3PROTO, exp->nat.set);

                nfnl_parse_nested(tb, CTA_EXPECT_NAT_MAX,
                                        cda[CTA_EXPECT_NAT-1]);

                if (tb[CTA_EXPECT_NAT_TUPLE-1]) {
                        __parse_tuple(tb[CTA_EXPECT_NAT_TUPLE-1],
                                      &exp->nat.orig,
                                      __DIR_ORIG,
                                      exp->nat.set);
                        set_bit(ATTR_EXP_NAT_TUPLE, exp->set);
                }
                if (tb[CTA_EXPECT_NAT_DIR-1]) {
                        exp->nat_dir =
                              ntohl(*((uint32_t *)
                                NFA_DATA(tb[CTA_EXPECT_NAT_DIR-1])));
                        set_bit(ATTR_EXP_NAT_DIR, exp->set);
                }
        }
        if (cda[CTA_EXPECT_FN-1]) {
                strcpy(exp->expectfn, NFA_DATA(cda[CTA_EXPECT_FN-1]));
                exp->expectfn[__NFCT_EXPECTFN_MAX-1] = '\0';
                set_bit(ATTR_EXP_FN, exp->set);
        }
}