container_of()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

#include <stdio.h> /* #define container_of(ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );}) #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) */ struct test { int a; char *b; }; int main(int argc, char *argv[]) { //通过struct test成员b返回struct的入口地址 //container_of(&tmp.b, (struct test), b);    struct test tmp; struct test *ptmp; int offset; tmp.a = 10; printf("&tmp.a = %02x, &tmp.b = %02x\n", &tmp.a, &tmp.b); //定义一个 _mptr指针， 类型为struct test结构体中b成员的类型 //typeof 为获取（（（struct test＊）0）->b)的类型，此处此类型为char* const typeof(((struct test *)0)->b) *_mptr = &tmp.b; printf("_mptr = %02x\n", _mptr); //#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) //TYPE是某struct的类型 0是一个假想TYPE类型struct,MEMBER是该struct中的一个成员.  //由于该struct的基地址为0, MEMBER的地址就是该成员相对与struct头地址的偏移量. offset = (int)(&((struct test *)0)->b); printf("offset = %d\n", offset); //_mptr的地址减去MEMBER在该struct中的偏移量得到的地址, 再转换成type型指针. 该指针就是struct的入口地址了. ptmp = (struct test *)((char *)_mptr - offset); printf("tmp = %02x, ptmp = %02x\n", &tmp, ptmp); printf("ptmp->a = %d\n", ptmp->a); return 0; } 输出结果： $ ./a.out &tmp.a = bfffe6a0, &tmp.b = bfffe6a4 _mptr = bfffe6a4 offset = 4 tmp = bfffe6a0, ptmp = bfffe6a0 ptmp->a = 10

iptables command and rules

$ iptables [-t table] command [match] [target]



iptables有5个链：PREROUTING，INPUT，FORWARD，OUTPUT，POSTROUTING；4个表：filter,nat,magle,raw.

4个表的优先级由高到低为：raw->mangle->nat->filter.

[-t table] 选项允许使用标准表之外的任何表。表是包含仅处理特定类型信息包的规则和链的信息包过滤表。该选项不是必需的，如果未指定， 则 filter 用作缺省表。
filter：表用于一般的信息包过滤。包括链表：
          INPUT：主要与想要进入本机的封包有关；
          OUTPUT：主要与本机所要送出的封包有关；
          FORWARD： 用于转发，与nat table 相关性较高。
nat：主要在进行来源与目的之 IP 或 port 的转换，与 Linux 本机较无关，主要与 Linux 主机后的区域网路内电脑较有相关。包括链表：
          PREROUTING：在进行路由判断之前所要进行的规则(DNAT/REDIRECT)
          POSTROUTING：在进行路由判断之后所要进行的规则(SNAT/MASQUERADE)
          OUTPUT：与发送出去的封包有关。
mangle：该表包含一些规则来标记用于高级路由的信息包，该表包含 PREROUTING 和 OUTPUT 链。 

RAW表只使用在PREROUTING链和OUTPUT链上,因为优先级最高，从而可以对收到的数据包在连接跟踪前进行处理。一但用户使用了RAW 表,在某个链上,RAW表处理完后,将跳过NAT表和 ip_conntrack处理,即不再做地址转换和数据包的链接跟踪处理了.RAW表可以应用在那些不需要做nat的情况下，以提高性能。如大量访问的web服务器，可以让80端口不再让iptables做数据包的链接跟踪处理，以提高用户的访问速度。


各链表关系如下：

hash list

1. 拉链法实现HASH链表

    #include <stdio.h>
    #include <string.h>
    
    #define N 14
    #define M 14
    
     typedef struct struct_node{
         int key;
         struct struct_node *next;
     }node;
    
     int get_hash_key(int key)
     {
         return key % 11;
     }
    
     node **hash_init(node **hash_table,int m)
     {
         int i = 0;
    
         for ( ; i < m ; i++ )
             hash_table[i] = NULL;
    
         return hash_table;
     }
    
     node **create_hash_table(node **hash_table,int *a)
     {
         node *m;
         int i = 0,key;
    
         for ( ; i < N ; i++ ) {
             key = get_hash_key(a[i]);
             m = (node *)malloc(sizeof(node));
             if ( !m ) {
                 printf("malloc failed.\n");
                 exit(0);
             }
             m->key = a[i];
    
             if ( hash_table[key] == NULL ) {
                 hash_table[key] = m;
                 m->next = NULL;
                 continue;
             }
    
             m->next = hash_table[key];
             hash_table[key] = m;
         }
    
         return hash_table;
     }
    
     node *search_node(node **hash_table,int key)
     {
         node *p;
         int i = 0,hash_key;
    
         hash_key = get_hash_key(key);
         p = hash_table[hash_key];
    
         if ( !p )
             return NULL;
    
         while ( p ) {
             if ( p->key == key )
                 return p;
             p = p->next;
         }
    
         return NULL;
     }
    
     node **delete_node(node **hash_table,int key)
     {
         node *p,*q,*head;
    
         p = hash_table[get_hash_key(key)];
         if ( !p ) {
             printf("[-] no key in hash_table .\n");
             return hash_table;
         }
    
         if ( p->next == NULL ) {
             hash_table[get_hash_key(key)] = NULL;
             return hash_table;
         }
    
         while ( p != NULL ) {
             if ( p->key == key ) {
                 if ( p == hash_table[get_hash_key(key)] ) {
                     hash_table[get_hash_key(key)] = p->next;
                     return hash_table;
                 }
                 else{
                     q->next = p->next;
                     return hash_table;
                 }
             }
             q = p;
             p = p->next;
         }
    
         return NULL;
     }
    
     void print_node(node *head)
     {
         if ( !head )
             return ;
    
         while ( head != NULL ) {
             printf("%d,",head->key);
             head = head->next;
         }
     }
    
     void print_hash_table(node **hash_table)
     {
         int i = 0;
    
         for ( ; i < M ; i++ ) {
             print_node(hash_table[i]);
             printf("\n");
         }
     }
    
     void destroy_node(node *head)
     {
         node *p;
    
         while ( head != NULL ) {
             p = head->next;
             free(head);
             head = p;
         }
     }
    
     void destroy_hash_table(node **hash_table)
     {
         int i = 0;
    
         for ( ; i < N ; i++ )
             destroy_node(hash_table[i]);
     }
    
     int main(void)
     {
         node *hash_table[M],*p,**s;
         int a[N] = {47,7,29,11,16,92,22,8,3,50,37,89,94,21};
    
         hash_init(hash_table,M);
         printf("[+] hash init ok.\n");
         create_hash_table(hash_table,a);
         printf("[+] hash table create ok.\n");
         print_hash_table(hash_table);
    
         printf("..................................\n");
    
         p = search_node(hash_table,29);
         printf("%d\n",p->key);
         printf("..................................\n");
    
         s = delete_node(hash_table,8);
         if ( !s )
             printf("[-] hash_table NULL.\n");
         print_hash_table(s);
    
         destroy_hash_table(hash_table);
         printf("[+] destroy hash_table ok.\n");
    
         return 0;
     }