免费注册 查看新帖 |

ChinaUnix.net

  平台 论坛 博客 文库
最近访问板块 发新帖
查看: 53235 | 回复: 77

iptables 源码分析 [复制链接]

论坛徽章:
0
发表于 2005-12-07 09:17 |显示全部楼层
这里只是一个笔记,我会将进一步修改、整理,补充后的版本发在我的个人主页上:
http://www.skynet.org.cn/viewthr ... 2&page=1#pid262

应用软件源码分析发在这里不知道是否合适:D

最近看了一下iptables的实现,现在想陆续把看的心得贴出来,和大家讨论一下,共同学习……

一、规则的显示
选择先来说明规则的显示,因为他涉及到的东东简单,而且又全面,了解了规则的显示,对于其它操作的了解就显得容易了。

iptables version 1.2.7

iptables有两条线:ipv4 和ipv6,这里只分析v4的,因为v6偶暂时还用不着,没有去看。

iptables_standardone.c
主函数:
int main(int argc, char *argv[])
{
        int ret;
        char *table = "filter";                                /*默认的表是filter*/
        iptc_handle_t handle = NULL;

        program_name = "iptables";
        program_version = IPTABLES_VERSION;

#ifdef NO_SHARED_LIBS
        init_extensions();
#endif

        /*进入命令行处理函数*/
ret = do_command(argc, argv, &table, &handle);
        if (ret)
                ret = iptc_commit(&handle);

        if (!ret)
                fprintf(stderr, "iptables: %s\n",
                        iptc_strerror(errno));

        exit(!ret);
}
table表示表的名称,就是iptables -t 后面跟的那个,默认是"filter"
iptc_handle_t handle = NULL;  这个东东很重要,现在初始化NULL,后面他被用来存储一个表的所有规则的快照。
        program_name = "iptables";
        program_version = IPTABLES_VERSION;
设置名称和版本。
#ifdef NO_SHARED_LIBS
        init_extensions();
#endif
iptables很多东东,是用共享库*.so的形式(我们安装会,可以在诸如/lib/iptables下边看到),如果不采用共享库,则进行一个初始化操作。我们假设是采用共享库的,忽略它。

然后就进入核心处理模块:
do_command(argc, argv, &table, &handle);

do_command 函数是整个系统的核心,负责处理整个用户的输入命令。函数首先对一些结构、变量进行初始化,初始化完毕后,进入while循环,分析用户输入的命令,设置相关的标志变量,然后根据相应标志,调用对应的处理函数。

struct ipt_entry fw, *e = NULL;
        int invert = 0;
        unsigned int nsaddrs = 0, ndaddrs = 0;
        struct in_addr *saddrs = NULL, *daddrs = NULL;

        int c, verbose = 0;
        const char *chain = NULL;
        const char *shostnetworkmask = NULL, *dhostnetworkmask = NULL;
        const char *policy = NULL, *newname = NULL;
        unsigned int rulenum = 0, options = 0, command = 0;
        const char *pcnt = NULL, *bcnt = NULL;
        int ret = 1;
        struct iptables_match *m;
        struct iptables_target *target = NULL;
        struct iptables_target *t;
        const char *jumpto = "";
        char *protocol = NULL;
        const char *modprobe = NULL;

        /*初始化变量*/
memset(&fw, 0, sizeof(fw));

        opts = original_opts;
        global_option_offset = 0;

        /* re-set optind to 0 in case do_command gets called
         * a second time */
        optind = 0;

        /*初始化两个全局变量*/
/* clear mflags in case do_command gets called a second time
         * (we clear the global list of all matches for security)*/
        for (m = iptables_matches; m; m = m->next) {
                m->mflags = 0;
                m->used = 0;
        }

        for (t = iptables_targets; t; t = t->next) {
                t->tflags = 0;
                t->used = 0;
        }
ps:开头一大堆的变量定义和初始化,可以在程序分析的时候看它们的作用,有两个全局结构变量很重要:iptables_matches和iptables_targets。现在来分析他们的作用会有一点困难,因为它们涉及到了太多方面的东东,这里,可以先把它们“想像成”用户空间用来读取内核规则的结构(当然,这有点错误)。

/*开始化析命令行*/
while ((c = getopt_long(argc, argv,
          "-A:C:D:R:I:L::M:F::Z::N:X::E:P:Vh::o:p:s:d:j:i:fbvnt:m:xc:",
                                           opts, NULL)) != -1)
{
}

这个while循环处理所有的用户输入,对应规则输出-L,有:
case 'L':
add_command(&command, CMD_LIST, CMD_ZERO,
invert);
if (optarg) chain = optarg;
else if (optind < argc && argv[optind][0] != '-'
&& argv[optind][0] != '!')
chain = argv[optind++];
break;

add_command函数负责将命令标志变量command与令标志 CMD_LIST求&运算, CMD_ZERO只是一个附加的判断标志而已,invert);然后,从命令行中取得要显示的链名(如果有的话)。

与此相关的还有用t参数指定了表名:
                case 't':
                        if (invert)
                                exit_error(PARAMETER_PROBLEM,
                                           "unexpected ! flag before --table");
                        *table = argv[optind-1];
                        break;
即,如果有’t’参数,则取’t’后跟的表名:*table = argv[optind-1],否则,它应该是主函数中默认的filter表。

命令处理完毕后,即进入执行模块:
/*因为程序定义了共享库的话,iptables_matches/iptables_target这两个结构运行至此是NULL,并且target也是NULL,对于规则显示而言,这一部份的处理目前没有实际意义,回过头再来看这一段更易理解。final_check成员函数的作用是作最终的标志检查,如果检测失则,则退出*/
        for (m = iptables_matches; m; m = m->next) {
                if (!m->used)
                        continue;

                m->final_check(m->mflags);
        }

        if (target)
                target->final_check(target->tflags);


接着对参数作一些必要的合法性检查:
        /* Fix me: must put inverse options checking here --MN */

        if (optind < argc)
                exit_error(PARAMETER_PROBLEM,
                           "unknown arguments found on commandline");
        if (!command)
                exit_error(PARAMETER_PROBLEM, "no command specified");
        if (invert)
                exit_error(PARAMETER_PROBLEM,
                           "nothing appropriate following !");

/*对于如果要进行(CMD_REPLACE | CMD_INSERT | CMD_DELETE | CMD_APPEND)处理来说,如果没有设置来源/目的地址及掩码,则给予它们一个默认值*/
        if (command & (CMD_REPLACE | CMD_INSERT | CMD_DELETE | CMD_APPEND)) {
                if (!(options & OPT_DESTINATION))
                        dhostnetworkmask = "0.0.0.0/0";
                if (!(options & OPT_SOURCE))
                        shostnetworkmask = "0.0.0.0/0";
        }



/*对来源/目的地址及掩码进行拆分,它们总是以 addr/mask的形式来出现的,根据’/’前面的字符串取得地址值,根据’/’后面的掩码位数,求得正确的掩码值,值得注意的是,同时要处理主机地址和网络地址的情况*/
        if (shostnetworkmask)
                parse_hostnetworkmask(shostnetworkmask, &saddrs,
                                      &(fw.ip.smsk), &nsaddrs);

        if (dhostnetworkmask)
                parse_hostnetworkmask(dhostnetworkmask, &daddrs,
                                      &(fw.ip.dmsk), &ndaddrs);

/*然后检查来源/目的网络地址的合法性*/
        if ((nsaddrs > 1 || ndaddrs > 1) &&
            (fw.ip.invflags & (IPT_INV_SRCIP | IPT_INV_DSTIP)))
                exit_error(PARAMETER_PROBLEM, "! not allowed with multiple"
                           " source or destination IP addresses");

/*对命令行格式进行合法性检查*/
generic_opt_check(command, options);


如果前面只是热身的话,那么从现在开始,就进入实质性阶段了:

do_command函数最后一个参数handle,是一个指向了具体表,如filter、nat表的句柄,这里判断,如果handle为空,则调用iptc_init,根据table的名称,让handle指针指向相应的表的地址空间,也就是把对应表的所有信息从内核中取出来:
        /* only allocate handle if we weren't called with a handle */
        if (!*handle)
                *handle = iptc_init(*table);

        /*如果获取换败,将试着插入模块,再次获取*/
        if (!*handle) {
                /* try to insmod the module if iptc_init failed */
                iptables_insmod("ip_tables", modprobe);
                *handle = iptc_init(*table);
        /*仍然失败,则退出*/
        if (!*handle)
                exit_error(VERSION_PROBLEM,
                           "can't initialize iptables table `%s': %s",
                           *table, iptc_strerror(errno));


/*继续进行一些简单的判断*/
if (command == CMD_APPEND
            || command == CMD_DELETE
            || command == CMD_INSERT
            || command == CMD_REPLACE) {
                /*List命令不在判断之列,暂时不分析*/
        }


/*判断命令标志,调用相关函数进行处理*/
switch (command) {
        case CMD_LIST:
                ret = list_entries(chain,
                                   options&OPT_VERBOSE,
                                   options&OPT_NUMERIC,
                                   options&OPT_EXPANDED,
                                   options&OPT_LINENUMBERS,
                                   handle);
}
list_entries是规则显示的主要处理函数。
Options是显示的标志变量:
OPT_VERBOSE:对应-v
OPT_NUMERIC:对应-n
OPT_EXPANDED:对应-x
OPT_LINENUMBERS: -l

看来很简单,说了这么大一圈子,就是调用 iptc_init获取表的规则信息,调用list_entries函数显示规则。

[ 本帖最后由 独孤九贱 于 2006-3-5 14:49 编辑 ]

论坛徽章:
0
发表于 2005-12-07 09:18 |显示全部楼层

iptc_init

1.1        表的查找
再回到iptc_init 函数上来,它根据表名,从内核获取对应的表的相关信息,handle是一个iptc_handle_t类型的指针,在libiptc.c中,有如下定义:
/* Transparent handle type. */
typedef struct iptc_handle *iptc_handle_t;

在Libip4tc中:
#define STRUCT_TC_HANDLE        struct iptc_handle
在Libiptc.c中,可以找到STRUCT_TC_HANDLE的定义:
STRUCT_TC_HANDLE
{
        /* Have changes been made? */
        int changed;
        /* Size in here reflects original state. */
        STRUCT_GETINFO info;

        struct counter_map *counter_map;
        /* Array of hook names */
        const char **hooknames;

        /* Cached position of chain heads (NULL = no cache). */
        unsigned int cache_num_chains;
        unsigned int cache_num_builtins;


        /* Rule iterator: terminal rule */
        STRUCT_ENTRY *cache_rule_end;

        /* Number in here reflects current state. */
        unsigned int new_number;
        STRUCT_GET_ENTRIES entries;
};

再来看看iptc_init函数,同样在在Libip4tc中,有如下定义:
#define TC_INIT                        iptc_init

在Libiptc.c中,可以看到函数的实现,基本上iptables与内核的交互,都是使用setsockopt函数来实现的,对于获取取规是信息来说,标志位是SO_GET_INFO,而从内核返回回来的规则信息是一个STRUCT_GETINFO结构:

TC_HANDLE_T TC_INIT(const char *tablename)
{
        TC_HANDLE_T h;
        STRUCT_GETINFO info;
        unsigned int i;
        int tmp;
        socklen_t s;

        iptc_fn = TC_INIT;

        if (sockfd != -1)
                close(sockfd);

        /*为获取信息打开一个套接字接口*/
        sockfd = socket(TC_AF, SOCK_RAW, IPPROTO_RAW);
        if (sockfd < 0)
                return NULL;

        s = sizeof(info);
        if (strlen(tablename) >= TABLE_MAXNAMELEN) {
                errno = EINVAL;
                return NULL;
        }
        strcpy(info.name, tablename);
/*获取规则信息*/
        if (getsockopt(sockfd, TC_IPPROTO, SO_GET_INFO, &info, &s) < 0)
                return NULL;

        if ((h = alloc_handle(info.name, info.size, info.num_entries))
            == NULL)
                return NULL;

/* Too hard --RR */
#if 0
        sprintf(pathname, "%s/%s", IPT_LIB_DIR, info.name);
        dynlib = dlopen(pathname, RTLD_NOW);
        if (!dynlib) {
                errno = ENOENT;
                return NULL;
        }
        h->hooknames = dlsym(dynlib, "hooknames");
        if (!h->hooknames) {
                errno = ENOENT;
                return NULL;
        }
#else
        h->hooknames = hooknames;
#endif

        /* Initialize current state */
        h->info = info;
        h->new_number = h->info.num_entries;
        for (i = 0; i < h->info.num_entries; i++)
                h->counter_map[i]
                        = ((struct counter_map){COUNTER_MAP_NORMAL_MAP, i});

        h->entries.size = h->info.size;

        tmp = sizeof(STRUCT_GET_ENTRIES) + h->info.size;

        if (getsockopt(sockfd, TC_IPPROTO, SO_GET_ENTRIES, &h->entries,
                       &tmp) < 0) {
                free(h);
                return NULL;
        }

        CHECK(h);
        return h;
}

        函数为h分配空间,然后赋予相应的值。要理解这个函数,还需要了解STRUCT_GETINFO结构和分配内存空间的函数alloc_handle。

#define STRUCT_GETINFO                struct ipt_getinfo

/* The argument to IPT_SO_GET_INFO */

struct ipt_getinfo
{
        /* Which table: caller fills this in. */
        char name[IPT_TABLE_MAXNAMELEN];

        /* Kernel fills these in. */
        /* Which hook entry points are valid: bitmask */
        unsigned int valid_hooks;

        /* Hook entry points: one per netfilter hook. */
        unsigned int hook_entry[NF_IP_NUMHOOKS];

        /* Underflow points. */
        unsigned int underflow[NF_IP_NUMHOOKS];

        /* Number of entries */
        unsigned int num_entries;

        /* Size of entries. */
        unsigned int size;
};

/* Allocate handle of given size */
static TC_HANDLE_T
alloc_handle(const char *tablename, unsigned int size, unsigned int num_rules)
{
        size_t len;
        TC_HANDLE_T h;

        len = sizeof(STRUCT_TC_HANDLE)
                + size
                + num_rules * sizeof(struct counter_map);

        if ((h = malloc(len)) == NULL) {
                errno = ENOMEM;
                return NULL;
        }

        h->changed = 0;
        h->cache_num_chains = 0;
        h->cache_chain_heads = NULL;
        h->counter_map = (void *)h
                + sizeof(STRUCT_TC_HANDLE)
                + size;
        strcpy(h->info.name, tablename);
        strcpy(h->entries.name, tablename);

        return h;
}

论坛徽章:
0
发表于 2005-12-07 09:20 |显示全部楼层

list_entries

函数list_entries用于显示表下边的链:
/*显示某table下的chain*/
static int
list_entries(const ipt_chainlabel chain, int verbose, int numeric,
             int expanded, int linenumbers, iptc_handle_t *handle)
{
        int found = 0;
        unsigned int format;
        const char *this;

        format = FMT_OPTIONS;                                /*设置输出格式*/
        if (!verbose)                                        /*详细输出模式,,对应-v ,显示匹配的包的数目,包的大小等*/
                format |= FMT_NOCOUNTS;
        else
                format |= FMT_VIA;                       

        if (numeric)                                        /*对应-n,以数字的形式输出地址和端口*/
                format |= FMT_NUMERIC;

        if (!expanded)                                        /*对应-x,expand numbers (display exact values)*/
                format |= FMT_KILOMEGAGIGA;

        if (linenumbers)                                /*输出行的编号*/
                format |= FMT_LINENUMBERS;

        for (this = iptc_first_chain(handle);                /*遍历当前table的所有chain*/
             this;
             this = iptc_next_chain(handle))
{               
                const struct ipt_entry *i;
                unsigned int num;

                if (chain && strcmp(chain, this) != 0)        /*匹配指定chain名,这里用chain &&,即若不指定chain,输出所有chain*/
                        continue;

                if (found) printf("\n");

                print_header(format, this, handle);        /*输出标头*/
                i = iptc_first_rule(this, handle);        /*移至当前chain的第一条规则*/

                num = 0;
                while (i) {
                        print_firewall(i,                                        /*输出当前规则*/
                                       iptc_get_target(i, handle),
                                       num++,
                                       format,
                                       *handle);
                        i = iptc_next_rule(i, handle);                        /*移至下一条规则*/
                }
                found = 1;
        }

        errno = ENOENT;
        return found;
}

可见,在函数中,由iptc_first_chain和iptc_next_chain实现了遍历,iptc_first_rule和iptc_next_rule实现了链中规是的遍历,print_firewall函数在遍历到规则的时候,向终端输出防火墙规则,其第二个参数iptc_get_target又用于获取规则的target。

前面提到过,在内核中,handler指针指向了从内核中返回的对应的表的信息,handler对应的结构中,涉及到链的结构成员主要有两个:
        struct chain_cache *cache_chain_heads;
        struct chain_cache *cache_chain_iteration;
前者用于指向第一个链,后者指向当前链。而struct chain_cache的定义如下:
struct chain_cache
{
        char name[TABLE_MAXNAMELEN];                /*链名*/
        STRUCT_ENTRY *start;                        /*该链的第一条规则*/
        STRUCT_ENTRY *end;                        /*该链的最后一条规则*/
};
理解了这两个成员,和结构struct chain_cache,再来理解链的遍历函数就不难了。所谓链的遍历,就是将handler对应成员的值取出来。

#define TC_FIRST_CHAIN                iptc_first_chain
#define TC_NEXT_CHAIN                iptc_next_chain

函数TC_FIRST_CHAIN用于返回第一个链:
/* Iterator functions to run through the chains. */
const char *
TC_FIRST_CHAIN(TC_HANDLE_T *handle)
{
        /*链首为空,则返回NULL*/
if ((*handle)->cache_chain_heads == NULL
            && !populate_cache(*handle))
                return NULL;

        /*当前链的指针指向链表首部*/
        (*handle)->cache_chain_iteration
                = &(*handle)->cache_chain_heads[0];
        /*返回链的名称*/
        return (*handle)->cache_chain_iteration->name;
}

/* Iterator functions to run through the chains.  Returns NULL at end. */
const char *
TC_NEXT_CHAIN(TC_HANDLE_T *handle)
{
        /*很简单,用heads开始,用++就可以实现遍历了*/
(*handle)->cache_chain_iteration++;

        if ((*handle)->cache_chain_iteration - (*handle)->cache_chain_heads
            == (*handle)->cache_num_chains)
                return NULL;

        return (*handle)->cache_chain_iteration->name;
}

规则的遍历
当遍历到某个链的时候,接下来,就需要遍历当前链下的所有规则了,输出之了。前面叙述了链的遍历,那么规则的遍历,应该就是根据链的名称,找到对应的成员结构struct chain_cache ,这里面包含了当前链的第一条规则与最后一条规则的指针:

#define TC_FIRST_RULE                iptc_first_rule
#define TC_NEXT_RULE                iptc_next_rule
/* Get first rule in the given chain: NULL for empty chain. */
const STRUCT_ENTRY *
TC_FIRST_RULE(const char *chain, TC_HANDLE_T *handle)
{
        struct chain_cache *c;

        c = find_label(chain, *handle);        /*根据链名,返回对应的struct chain_cache结构*/
        if (!c) {                                                /*没有找到,返回NULL*/
                errno = ENOENT;
                return NULL;
        }

        /* Empty chain: single return/policy rule */
        if (c->start == c->end)                /*如果是空链*/
                return NULL;

        (*handle)->cache_rule_end = c->end;
        return c->start;                                /*返回链的首条规则*/
}

/* Returns NULL when rules run out. */
const STRUCT_ENTRY *
TC_NEXT_RULE(const STRUCT_ENTRY *prev, TC_HANDLE_T *handle)
{
        if ((void *)prev + prev->next_offset
            == (void *)(*handle)->cache_rule_end)
                return NULL;

        return (void *)prev + prev->next_offset;
}

要更解TC_NEXT_RULE函数是如何实现查找下一条规则的,需要首先理解STRUCT_ENTRY结构:
#define STRUCT_ENTRY                struct ipt_entry
ipt_entry结构用于存储链的规则,每一个包过滤规则可以分成两部份:条件和动作。前者在Netfilter中,称为match,后者称之为target。Match又分为两部份,一部份为一些基本的元素,如来源/目的地址,进/出网口,协议等,对应了struct ipt_ip,我们常常将其称为标准的match,另一部份match则以插件的形式存在,是动态可选择,也允许第三方开发的,常常称为扩展的match,如字符串匹配,p2p匹配等。同样,规则的target也是可扩展的。这样,一条规则占用的空间,可以分为:struct ipt_ip+n*match+n*target,(n表示了其个数,这里的match指的是可扩展的match部份)。基于此,规则对应的结构如下:
/* This structure defines each of the firewall rules.  Consists of 3
   parts which are 1) general IP header stuff 2) match specific
   stuff 3) the target to perform if the rule matches */
struct ipt_entry
{
        struct ipt_ip ip;                /*标准的match部份*/

        /* Mark with fields that we care about. */
        unsigned int nfcache;

        /* Size of ipt_entry + matches */
        u_int16_t target_offset;                /*target的开始位置,是sizeof(ipt_entry+n*match)*/
        /* Size of ipt_entry + matches + target */
        u_int16_t next_offset;                /*下一条规则相对于本条规则的位置,是sizeof(ipt_entry)加上所有的match,以及所有的target*/

        /* Back pointer */
        unsigned int comefrom;

        /* Packet and byte counters. */
        struct ipt_counters counters;

        /* The matches (if any), then the target. */
        unsigned char elems[0];
};

有了这样的基础,就不难理解遍历规则中,寻找下一条规则语句:
return (void *)prev + prev->next_offset;
即是本条规则加上下一条规则的偏移值。

论坛徽章:
0
发表于 2005-12-07 09:21 |显示全部楼层
输出规则
print_firewall 函数用于规则的输出:
print_firewall(i, iptc_get_target(i, handle), num++,format,*handle);
i:当前的规则;
iptc_get_target(i, handle):用于规则的target部份的处理;
num:规则序号;
format:输出格式;
handler:表的信息;


/* e is called `fw' here for hysterical raisins */
static void
print_firewall(const struct ipt_entry *fw,
               const char *targname,
               unsigned int num,
               unsigned int format,
               const iptc_handle_t handle)
{
        struct iptables_target *target = NULL;
        const struct ipt_entry_target *t;
        u_int8_t flags;
        char buf[BUFSIZ];

        if (!iptc_is_chain(targname, handle))
                target = find_target(targname, TRY_LOAD);
        else
                target = find_target(IPT_STANDARD_TARGET, LOAD_MUST_SUCCEED);

        t = ipt_get_target((struct ipt_entry *)fw);
        flags = fw->ip.flags;

        if (format & FMT_LINENUMBERS)                        /*输出行号*/
                printf(FMT("%-4u ", "%u "), num+1);

        if (!(format & FMT_NOCOUNTS)) {                        /*详细模式,列出计数器*/
                print_num(fw->counters.pcnt, format);        /*匹配当前规则的数据包个数*/
                print_num(fw->counters.bcnt, format);        /*--------------------大小*/
        }
        /*输出目标名称*/
        if (!(format & FMT_NOTARGET))                        /*目标名称,即拦截、通过等动作*/
                printf(FMT("%-9s ", "%s "), targname);

        /*输出协议名*/
        fputc(fw->ip.invflags & IPT_INV_PROTO ? '!' : ' ', stdout);
        {
                char *pname = proto_to_name(fw->ip.proto, format&FMT_NUMERIC);
                if (pname)
                        printf(FMT("%-5s", "%s "), pname);
                else
                        printf(FMT("%-5hu", "%hu "), fw->ip.proto);
        }

        /*输出选项字段*/
        if (format & FMT_OPTIONS) {
                if (format & FMT_NOTABLE)
                        fputs("opt ", stdout);
                fputc(fw->ip.invflags & IPT_INV_FRAG ? '!' : '-', stdout);        //#define IP_FW_INV_FRAG  0x0080  /* Invert the sense of IP_FW_F_FRAG. */       
                fputc(flags & IPT_F_FRAG ? 'f' : '-', stdout);                        //#define IP_FW_F_FRAG        0x0004  /* Set if rule is a fragment rule */
                fputc(' ', stdout);
        }

        if (format & FMT_VIA) {
                char iface[IFNAMSIZ+2];

                if (fw->ip.invflags & IPT_INV_VIA_IN) {                /*输入端口取反标志*/
                        iface[0] = '!';                                /*设置取反标志符*/
                        iface[1] = '\0';
                }
                else iface[0] = '\0';

                if (fw->ip.iniface[0] != '\0') {
                        strcat(iface, fw->ip.iniface);
                }
                else if (format & FMT_NUMERIC) strcat(iface, "*");
                else strcat(iface, "any");
                printf(FMT(" %-6s ","in %s "), iface);                /*输出输入端口*/

                if (fw->ip.invflags & IPT_INV_VIA_OUT) {        /*输出端口取反标志*/
                        iface[0] = '!';                                /*设置取反标志符*/
                        iface[1] = '\0';
                }
                else iface[0] = '\0';

                if (fw->ip.outiface[0] != '\0') {
                        strcat(iface, fw->ip.outiface);
                }
                else if (format & FMT_NUMERIC) strcat(iface, "*");               
                else strcat(iface, "any");
                printf(FMT("%-6s ","out %s "), iface);                        /*输出输出端口*/
        }                /*end print in/out interface */

        /*输出源地址及掩码*/
        fputc(fw->ip.invflags & IPT_INV_SRCIP ? '!' : ' ', stdout);                /*源地址取反标志*/
        if (fw->ip.smsk.s_addr == 0L && !(format & FMT_NUMERIC))                /*源地址为任意*/
                printf(FMT("%-19s ","%s "), "anywhere");
        else {                                                                       
                if (format & FMT_NUMERIC)
                        sprintf(buf, "%s", addr_to_dotted(&(fw->ip.src)));
                else
                        sprintf(buf, "%s", addr_to_anyname(&(fw->ip.src)));
                strcat(buf, mask_to_dotted(&(fw->ip.smsk)));
                printf(FMT("%-19s ","%s "), buf);
        }
       
        /*输出目的地址及掩码*/
        fputc(fw->ip.invflags & IPT_INV_DSTIP ? '!' : ' ', stdout);
        if (fw->ip.dmsk.s_addr == 0L && !(format & FMT_NUMERIC))
                printf(FMT("%-19s","-> %s"), "anywhere");
        else {
                if (format & FMT_NUMERIC)
                        sprintf(buf, "%s", addr_to_dotted(&(fw->ip.dst)));
                else
                        sprintf(buf, "%s", addr_to_anyname(&(fw->ip.dst)));
                strcat(buf, mask_to_dotted(&(fw->ip.dmsk)));
                printf(FMT("%-19s","-> %s"), buf);
        }

        if (format & FMT_NOTABLE)
                fputs("  ", stdout);

        /*输出扩展的MATCH*/

        IPT_MATCH_ITERATE(fw, print_match, &fw->ip, format & FMT_NUMERIC);               

        /*输出扩展的TARGET*/
        if (target) {
                if (target->print)
                        /* Print the target information. */
                        target->print(&fw->ip, t, format & FMT_NUMERIC);
        } else if (t->u.target_size != sizeof(*t))
                printf("[%u bytes of unknown target data] ",
                       t->u.target_size - sizeof(*t));

        if (!(format & FMT_NONEWLINE))
                fputc('\n', stdout);
}

函数分为三部份:
输出标准的match部份;
输出扩展的match部份,调用IPT_MATCH_ITERATE实现;
调用对应的target的print函数输出target部份。

论坛徽章:
0
发表于 2005-12-07 09:22 |显示全部楼层

match的输出

match的输出
IPT_MATCH_ITERATE 宏用于实现扩展match的遍历。这个宏定义在内核include/Linux/Netfilter-ipv4/Ip_tables.h中:
#define IPT_MATCH_ITERATE(e, fn, args...)        \
({                                                \
        unsigned int __i;                        \
        int __ret = 0;                                \
        struct ipt_entry_match *__match;        \
                                                \
        for (__i = sizeof(struct ipt_entry);        \               
             __i < (e)->target_offset;                \               
             __i += __match->u.match_size) {        \
                __match = (void *)(e) + __i;        \
                                                \
                __ret = fn(__match , ## args);        \                /*每找到一个match,就交由fn函数来处理,在print_firewall中,传递过来的是函数print_match*/
                if (__ret != 0)                        \
                        break;                        \
        }                                        \
        __ret;                                        \
})

要理解这个宏,需要先了解规则的存储,前面提到过,因为match/target都是可变的,所以在内存中,采取了ip_entry+n*match+n*target,即在规则后,是连续的若干个match,而mathc后面,又是若干个target,在结构ip_entry中,成员u_int16_t target_offset;代表了target的偏移地址,即target的开始,match的结束。我们要查到当前规则对应的所有match,需要了解三个要素:
1、match从哪里开始:起始地址应该是 [当前规则地址+sizeof(struct ipt_entry)];
2、match从哪里结束:结束地址,应该是 [当前规则地址+target_offet];
3、每一个match的大小,在内核中,match对应的结构是ipt_entry_match,其成员u.match_size指明了当前match的大小;
这三点,对应了for循环:
for (__i = sizeof(struct ipt_entry);        __i < (e)->target_offset;        __i += __match->u.match_size)
这样,i就对应了某个match的偏移植,通过:
__match = (void *)(e) + __i;
就得到了match的地址。
再通过
__ret = fn(__match , ## args);       
输出之。
fn函数是在print_firewall中,传递过来的是函数print_match。

static int
print_match(const struct ipt_entry_match *m,
            const struct ipt_ip *ip,
            int numeric)
{
        /*根据match名称进行查找,返回一个iptables_match结构,然后调用其中封装的print函数输出该match的信息*/
struct iptables_match *match = find_match(m->u.user.name, TRY_LOAD);

        if (match) {
                if (match->print)
                        match->print(ip, m, numeric);
                else
                        printf("%s ", match->name);
        } else {
                if (m->u.user.name[0])
                        printf("UNKNOWN match `%s' ", m->u.user.name);
        }
        /* Don't stop iterating. */
        return 0;
}

这里涉及到两个重要的结构:
struct ipt_entry_match:在内核中用于存储扩展match信息
struct ipt_entry_match
{
        union {
                struct {
                        u_int16_t match_size;

                        /* Used by userspace */
                        char name[IPT_FUNCTION_MAXNAMELEN];
                } user;
                struct {
                        u_int16_t match_size;

                        /* Used inside the kernel */
                        struct ipt_match *match;
                } kernel;

                /* Total length */
                u_int16_t match_size;
        } u;

        unsigned char data[0];
};

struct iptables_match:用于用户级的match存储:
/* Include file for additions: new matches and targets. */
struct iptables_match
{
        /* Match链,初始为NULL */
struct iptables_match *next;

        /* Match名,和核心模块加载类似,作为动态链接库存在的Iptables Extension的命名规则为libipt_'name'.so */
        ipt_chainlabel name;

        /*版本信息,一般设为NETFILTER_VERSION */
        const char *version;

        /* Match数据的大小,必须用IPT_ALIGN()宏指定对界*/
        size_t size;

        /*由于内核可能修改某些域,因此size可能与确切的用户数据不同,这时就应该把不会被改变的数据放在数据区的前面部分,而这里就应该填写被改变的数据区大小;一般来说,这个值和size相同*/
        size_t userspacesize;

        /*当iptables要求显示当前match的信息时(比如iptables-m ip_ext -h),就会调用这个函数,输出在iptables程序的通用信息之后. */
        void (*help)(void);

        /*初始化,在parse之前调用. */
        void (*init)(struct ipt_entry_match *m, unsigned int *nfcache);

        /*扫描并接收本match的命令行参数,正确接收时返回非0,flags用于保存状态信息*/
        int (*parse)(int c, char **argv, int invert, unsigned int *flags,
                     const struct ipt_entry *entry,
                     unsigned int *nfcache,
                     struct ipt_entry_match **match);

        /* 前面提到过这个函数,当命令行参数全部处理完毕以后调用,如果不正确,应该
退出(exit_error())*/
        void (*final_check)(unsigned int flags);

        /*当查询当前表中的规则时,显示使用了当前match的规则*/
        void (*print)(const struct ipt_ip *ip,
                      const struct ipt_entry_match *match, int numeric);

        /*按照parse允许的格式将本match的命令行参数输出到标准输出,用于iptables-save命令. */
        void (*save)(const struct ipt_ip *ip,
                     const struct ipt_entry_match *match);

        /* NULL结尾的参数列表,struct option与getopt(3)使用的结构相同*/
        const struct option *extra_opts;

        /* Ignore these men behind the curtain: */
        unsigned int option_offset;
        struct ipt_entry_match *m;
        unsigned int mflags;
        unsigned int used;
#ifdef NO_SHARED_LIBS
        unsigned int loaded; /* simulate loading so options are merged properly */
#endif
};

理解了这两个结构后,再来看find_match函数:

论坛徽章:
0
发表于 2005-12-07 09:35 |显示全部楼层

find_match

即然match是以可扩展的形式表现出来,那么,当然就需要find_match这样的函数将它们一一找出来了。

前面说过,在输出规则的函数中:
IPT_MATCH_ITERATE(fw, print_match, &fw->ip, format & FMT_NUMERIC);
用来遍历每一个match,找到了后,就调用print_match来输出。print_match是调用find_match来查找的:

struct iptables_match *
find_match(const char *name, enum ipt_tryload tryload)
{
        struct iptables_match *ptr;

        for (ptr = iptables_matches; ptr; ptr = ptr->next) {
                if (strcmp(name, ptr->name) == 0)
                        break;
        }

#ifndef NO_SHARED_LIBS
        if (!ptr && tryload != DONT_LOAD) {
                char path[sizeof(IPT_LIB_DIR) + sizeof("/libipt_.so")
                         + strlen(name)];
                sprintf(path, IPT_LIB_DIR "/libipt_%s.so", name);
                if (dlopen(path, RTLD_NOW)) {
                        /* Found library.  If it didn't register itself,
                           maybe they specified target as match. */
                        ptr = find_match(name, DONT_LOAD);

                        if (!ptr)
                                exit_error(PARAMETER_PROBLEM,
                                           "Couldn't load match `%s'\n",
                                           name);
                } else if (tryload == LOAD_MUST_SUCCEED)
                        exit_error(PARAMETER_PROBLEM,
                                   "Couldn't load match `%s':%s\n",
                                   name, dlerror());
        }
#else
        if (ptr && !ptr->loaded) {
                if (tryload != DONT_LOAD)
                        ptr->loaded = 1;
                else
                        ptr = NULL;
        }
        if(!ptr && (tryload == LOAD_MUST_SUCCEED)) {
                exit_error(PARAMETER_PROBLEM,
                           "Couldn't find match `%s'\n", name);
        }
#endif

        if (ptr)
                ptr->used = 1;

        return ptr;
}

分析这个函数,不从开头来看,先看这一段:
        if (!ptr && tryload != DONT_LOAD) {
                char path[sizeof(IPT_LIB_DIR) + sizeof("/libipt_.so")
                         + strlen(name)];
                sprintf(path, IPT_LIB_DIR "/libipt_%s.so", name);
                if (dlopen(path, RTLD_NOW)) {
                        /* Found library.  If it didn't register itself,
                           maybe they specified target as match. */
                        ptr = find_match(name, DONT_LOAD);

                        if (!ptr)
                                exit_error(PARAMETER_PROBLEM,
                                           "Couldn't load match `%s'\n",
                                           name);
                } else if (tryload == LOAD_MUST_SUCCEED)
                        exit_error(PARAMETER_PROBLEM,
                                   "Couldn't load match `%s':%s\n",
                                   name, dlerror());
        }
函数根据传递过来的match名称,从指定位置,加载对应的共享库,呵呵,这些共享库的源码,全部在Extensions目录下边:
如果加载它们,那么其_init函数就会被调用。这个初始化函数用来向iptables_match全局结构注册当前match的相关处理函数。(这样,我们可以写我们自己的用户空间的扩展match处理工具了)。注册好后,函数再来调用自己:
ptr = find_match(name, DONT_LOAD);
递归回来后,呵呵,就是开头那一段了,我们需要从已经注册好的全局结构中查找与当前match名称相同的iptables_match成员,因为该成员中封装了print函数,这样就可以顺利地输出来了:
比如,加载了libptc_tcp.so,它用来处理tcp的扩展,我们来看Extensions/libiptc_tcp.c:
static
struct iptables_match tcp
= { NULL,
    "tcp",
    IPTABLES_VERSION,
    IPT_ALIGN(sizeof(struct ipt_tcp)),
    IPT_ALIGN(sizeof(struct ipt_tcp)),
    &help,
    &init,
    &parse,
    &final_check,
    &print,
    &save,
    opts };

void
_init(void)
{
        register_match(&tcp);
}

构建了一个
iptables_match结构,其间有其对应的所有用户空间工具函数,如分析命令行、输出、保存……
然后,就调用register_match函数将其插入至全局结构iptables_match当中:
void
register_match(struct iptables_match *me)
{
        struct iptables_match **i;

        if (strcmp(me->version, program_version) != 0) {
                fprintf(stderr, "%s: match `%s' v%s (I'm v%s).\n",
                        program_name, me->name, me->version, program_version);
                exit(1);
        }

        if (find_match(me->name, DONT_LOAD)) {
                fprintf(stderr, "%s: match `%s' already registered.\n",
                        program_name, me->name);
                exit(1);
        }

        if (me->size != IPT_ALIGN(me->size)) {
                fprintf(stderr, "%s: match `%s' has invalid size %u.\n",
                        program_name, me->name, me->size);
                exit(1);
        }

        /* Append to list. */
        for (i = &iptables_matches; *i; i = &(*i)->next);
        me->next = NULL;
        *i = me;

        me->m = NULL;
        me->mflags = 0;
}

函数就是一个建立链表的过程。不进一步分析了。

论坛徽章:
0
发表于 2005-12-07 09:43 |显示全部楼层
暂时写到这里吧,太累了,原以为两三句就可以写完的,target的查找与match是一模一样的,就不写下去了,添加/删除等规则操作,改开空了继续写。

因为看iptables时,没有找到参考资料,所以文章中有些地方肯定有错。另一方面,因为时间关系,没有什么条理。不过还是欢迎感兴趣的朋友,一起讨论。

总结一下显示流程:
int main(int argc, char *argv[])  //主函数

int do_command()                    //命令行处理

*handle = iptc_init(*table);     //从内核获取表的规则快照

list_entries                              //显示规则

        for (this = iptc_first_chain(handle);
             this;
             this = iptc_next_chain(handle)) {
                const struct ipt_entry *i;
                unsigned int num;

                if (chain && strcmp(chain, this) != 0)
                        continue;

                if (found) printf("\n");

                print_header(format, this, handle);
                i = iptc_first_rule(this, handle);

                num = 0;
                while (i) {
                        print_firewall(i,
                                       iptc_get_target(i, handle),
                                       num++,
                                       format,
                                       *handle);
                        i = iptc_next_rule(i, handle);
                }
                found = 1;
        }
这一段是遍历表的每个链,然后再遍历链的每条规则,然后调用print_filrewall输出规则;

输出函数在输出标准的match,如地址/协议/网口后,就调用
        IPT_MATCH_ITERATE(fw, print_match, &fw->ip, format & FMT_NUMERIC);
遍历规则的每一个match,然后调用print_match输出。
print_match中,调用find_match加载共享库,共享库又通过_init函数向主函数的全局结构iptables_match注册自己的处理函数。
这样,根据match的名称,我们在print_match中,就可以很容易地调用其print函数,输出其值了。

target也是一样的原理。

休息一下……

论坛徽章:
0
发表于 2005-12-07 09:49 |显示全部楼层
兄弟,不错,谢谢。

论坛徽章:
0
发表于 2005-12-07 10:25 |显示全部楼层
去掉符号表情吧,要不太乱了

论坛徽章:
0
发表于 2005-12-07 10:32 |显示全部楼层
原帖由 albcamus 于 2005-12-7 10:25 发表
去掉符号表情吧,要不太乱了


我也没办法去啊,我把字打出来,一发表,它就成那样了
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

基于案例的 SQL 优化实战训练营

讲师:中电福富特级专家梁敬彬,参与本次课程培训,你将收获:
1. 能编写出较为高效的 SQL;
2. 能解决70%以上的数据库常见优化问题;
3. 能得到老师提供的高效的相关工具和解决方案;
4. 能举一反三,收获不仅仅是 SQL 优化。
现在购票享受8.8折优惠!
----------------------------------------
优惠时间:2019年3月20日前

大会官网>>
  

北京盛拓优讯信息技术有限公司. 版权所有 16024965号-6 北京市公安局海淀分局网监中心备案编号:11010802020122
中国互联网协会会员  联系我们:huangweiwei@it168.com
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP