源地址目标地址的匹配
    -s：指定作为源地址匹配，这里不能指定主机名称，必须是IP
        IP | IP/MASK | 0.0.0.0/0.0.0.0
        而且地址可以取反，加一个“!”表示除了哪个IP之外
     -d：表示匹配目标地址
     -p：用于匹配协议的（这里的协议通常有3种，TCP/UDP/ICMP）
     -i eth0：从这块网卡流入的数据
        流入一般用在INPUT和PREROUTING上
     -o eth0：从这块网卡流出的数据
        流出一般在OUTPUT和POSTROUTING上

对协议的扩展
   -p tcp :TCP协议的扩展。一般有三种扩展
      --dport XX-XX：指定目标端口,不能指定多个非连续端口,只能指定单个端口，比如
      --dport 21  或者 --dport 21-23 (此时表示21,22,23)
      --sport：指定源端口
      --tcpflags：TCP的标志位（SYN,ACK，FIN,PSH，RST,URG）
        对于它，一般要跟两个参数：
              1.检查的标志位
              2.必须为1的标志位
          --tcpflags syn,ack,fin,rst  syn = --syn
        表示检查这4个位，这4个位中syn必须为1，其他的必须为0。所以这个意思就是用于检测三次握手的第一次包的。对于这种专门匹配第一包的SYN为1的包，还有一种简写方式，叫做--syn
  -p udp：UDP协议的扩展
        --dport
        --sport
  -p icmp：icmp数据报文的扩展
        --icmp-type：
        echo-request(请求回显)，一般用8 来表示
        所以 --icmp-type 8 匹配请求回显数据包
        echo-reply （响应的数据包）一般用0来表示

扩展各种模块（-m）
      -m multiport：表示启用多端口扩展
      之后我们就可以启用比如 --dports 21,23,80

-j  ACTION
     常用的ACTION：
     DROP：悄悄丢弃
            一般我们多用DROP来隐藏我们的身份，以及隐藏我们的链表
     REJECT：明示拒绝
     ACCEPT：接受
            custom_chain：转向一个自定义的链
     DNAT
     SNAT
     MASQUERADE：源地址伪装
     REDIRECT：重定向：主要用于实现端口重定向
     MARK：打防火墙标记的
     RETURN：返回

_init()定义在xtables.h中，其定义如下：

#if defined(ALL_INCLUSIVE) || defined(NO_SHARED_LIBS)
#   ifdef _INIT
#       undef _init
#       define _init _INIT
#   endif
    extern void init_extensions(void);
#else
#   define _init __attribute__((constructor)) _INIT
#endif

__attribute__ ((constructor))会使函数在main()函数之前被执行
__attribute__ ((destructor))会使函数在main()退出后执行

#define TableName "nat"

#define P_TCP 1
#define P_UDP 2

#define PRE "PREROUTING"
#define POST "POSTROUTING"

#define S_NAT "SNAT"
#define D_NAT "DNAT"

#define MAX_PORT 65535

typedef struct _my_sock_addr {
    unsigned int n_ip;
    unsigned int n_port;
} my_addr;

int my_sock_addr(const char *ip, int port, my_addr *addr) {
    if (ip == NULL || addr == NULL) {
        return -1;
    }

    addr->n_ip = inet_addr(ip);
    addr->n_port = htons(port);
    return 0;
}


static int fill_entry(struct ipt_entry *e, __u32 size, __u32 match_size, __u32 src_ip, uint32_t src_msk, __u32 dst_ip, uint32_t dst_msk, __u32 protocol) {
    if (e == NULL) {
        printf("fill_entry_error! %x \n", *(char *) e);
        return -1;
    }
    /*初始化entry的源地址，目的地址和掩码*/
    e->ip.src.s_addr = src_ip;
    e->ip.dst.s_addr = dst_ip;
    if (src_msk == -1) {
        e->ip.dmsk.s_addr = htonl(0xFFFFFFFF << (32 - dst_msk));
    } else {
        e->ip.smsk.s_addr = htonl(0xFFFFFFFF << (32 - src_msk));
    }
    if (protocol == P_TCP) {
        e->ip.proto = IPPROTO_TCP;
    } else if (protocol == P_UDP) {
        e->ip.proto = IPPROTO_UDP;
    }

    e->target_offset = IPT_ALIGN(sizeof(struct ipt_entry)) +match_size ;
    e->next_offset = size;
    return 0;
}

static int fill_match(struct ipt_entry *e, struct ipt_entry_match *pm, __u32 match_size, __u16 src_port, __u16 dst_port, __u32 protocol) {
    if (e == NULL || pm == NULL ) {
        printf("fill_match_error! %x --- %x\n", *(char *) e, *(char *) pm);
        return -1;
    }

    pm = (struct ipt_entry_match*) e->elems;
    pm->u.user.match_size = match_size;
    if (protocol == P_TCP) {
        strcpy(pm->u.user.name, "tcp");
        struct ipt_tcp *ptcp = (struct ipt_tcp *) pm->data;
        if (src_port == 0) {
            ptcp->spts[0] = src_port;
            ptcp->spts[1] = MAX_PORT;
            ptcp->dpts[0] = dst_port;
            ptcp->dpts[1] = dst_port;
        } else {
            ptcp->spts[0] = src_port;
            ptcp->spts[1] = src_port;
            ptcp->dpts[0] = dst_port;
            ptcp->dpts[1] = MAX_PORT;
        }

    } else if (protocol == P_UDP) {
        strcpy(pm->u.user.name, "udp");
        struct ipt_udp *pudp = (struct ipt_udp *) pm->data;
        if (src_port == 0) {
            pudp->spts[0] = src_port;
            pudp->spts[1] = MAX_PORT;
            pudp->dpts[0] = dst_port;
            pudp->dpts[1] = dst_port;
        } else {
            pudp->spts[0] = src_port;
            pudp->spts[1] = src_port;
            pudp->dpts[0] = dst_port;
            pudp->dpts[1] = MAX_PORT;
        }
    }
    return 0;
}

static int fill_target(struct ipt_entry *e, struct ipt_entry_target *pt, struct nf_nat_multi_range_compat * p_target, const char *target, __u32 match_size,
        __u32 target_size, __u32 out_ip, __u16 out_port, __u32 protocol) {
    if (e == NULL || pt == NULL || p_target == NULL) {
        printf("fill_target_error! %x---%x---%x\n", *(char *) e, *(char *) pt, *(char *) p_target);
        return -1;
    }
    pt = (struct ipt_entry_target *) (e->elems + match_size);
    pt->u.target_size = target_size;
//  pt->target.u.kernel.target = NULL;
    strncpy(pt->u.user.name, target, sizeof(pt->u.user.name) - 1);

    p_target = (struct nf_nat_multi_range_compat *) pt->data;
//
    p_target->rangesize = 1;
    if (out_port == 0) {

        p_target->range[0].flags = 1;
    } else {
        p_target->range[0].flags = 3;
    }
    p_target->range[0].min_ip = out_ip;
    p_target->range[0].max_ip = out_ip;

    if (protocol == P_TCP) {
        p_target->range[0].min.tcp.port = out_port;
        p_target->range[0].max.tcp.port = out_port;
    } else if (protocol == P_UDP) {
        p_target->range[0].min.udp.port = out_port;
        p_target->range[0].max.udp.port = out_port;
    }

    return 0;
}

static int iptc_entry_add(struct iptc_handle *handle, const char *chain, const char *target, __u32 protocol, __u32 src_ip, __u16 src_port, __u32 src_msk,
        __u32 dst_ip, __u16 dst_port, __u32 dst_msk, __u32 out_ip, __u16 out_port) {

    if (handle == NULL || chain == NULL || target == NULL) {
        printf("iptc_entry_add error! %x---%x---%x\n", *(char *) handle, *(char *) chain, *(char *) target);
        return -1;
    }
    struct ipt_entry *e = NULL;  //对应规则的通用匹配
    struct ipt_entry_match pm; // match模块的匹配
    struct ipt_entry_target pt; // target 模块的匹配
    struct nf_nat_multi_range_compat p_target;
    __u32 target_size, match_size, size;

    __u32 ret = 0;

    if(protocol == P_TCP){
        match_size = IPT_ALIGN(sizeof(struct ipt_entry_match)) + IPT_ALIGN(sizeof(struct ipt_tcp));
    }else{
        match_size = IPT_ALIGN(sizeof(struct ipt_entry_match)) + IPT_ALIGN(sizeof(struct ipt_udp));
    }

    target_size = IPT_ALIGN(sizeof(struct ipt_entry_target))+ IPT_ALIGN(sizeof(struct nf_nat_multi_range_compat));

    size = IPT_ALIGN(sizeof(struct ipt_entry)) + target_size + match_size;

    e = malloc(size);
    memset((void *) e, 0, size);

    fill_entry(e, size, match_size, src_ip, src_msk, dst_ip, dst_msk, protocol);// 填充通用匹配规则

    fill_match(e, &pm, match_size, src_port, dst_port, protocol);// 填充match 模块规则

    fill_target(e, &pt, &p_target, target, match_size, target_size, out_ip, out_port, protocol);// 填充target 模块规则

    /* 在规则链中插入一项 */

    ret = iptc_append_entry(chain, e, handle);

    if (e) {
        free(e);
    }
    return ret;
}

int my_iptc_add(struct iptc_handle *handle, char* pro, my_addr *p_addr, my_addr *s_addr, __u32 out_ip) {

    __u32 ret = 0;
    __u32 protocol;
    __u32 src_msk = 0;
    __u32 dst_msk = 0;

    printf("iptc_operate  >>>>>  ======================srv_addr[%x:%x],prx_addr[%x:%x],out_ip[%x]\n",
            s_addr->n_ip,s_addr->n_port,p_addr->n_ip,p_addr->n_port,out_ip);

    if (strcmp(pro, "tcp") == 0) {
        protocol = P_TCP;
        ret = iptc_entry_add(handle, PRE, D_NAT, protocol, 0, 0, -1, p_addr->n_ip, ntohs(p_addr->n_port), dst_msk, s_addr->n_ip, s_addr->n_port); // 在PREROUTING链 添加DNAT转换规则
        if (ret < 0) {
            return ret;
        }
        ret = iptc_entry_add(handle, POST, S_NAT, protocol, 0, 0, -1, s_addr->n_ip, ntohs(s_addr->n_port), dst_msk, out_ip, 0);// 在POSTROUTING链 添加SNAT转换规则
        if (ret < 0) {
            return ret;
        }
    } else if (strcmp(pro, "udp") == 0) {
        protocol = P_UDP;
        ret = iptc_entry_add(handle, PRE, D_NAT, protocol, 0, 0, -1, p_addr->n_ip, ntohs(p_addr->n_port), dst_msk, s_addr->n_ip, s_addr->n_port);
        if (ret < 0) {
            return ret;
        }

        ret = iptc_entry_add(handle, POST, S_NAT, protocol, 0, 0, -1, s_addr->n_ip, ntohs(s_addr->n_port), dst_msk, out_ip, 0);
        if (ret < 0) {
            return ret;
        }
    } else {
        printf("input protocol error!\n");
        return -1;
    }
    return ret;
}

static int iptc_operate(char method, my_addr *srv_addr, my_addr *prx_addr, __u32 out_ip, char *proto) {
    int ret = 0;
    struct iptc_handle *h;
    h = iptc_init(TableName);
    if (!h) {
        return -1;
    }
    if (method == 'A') {
        ret = my_iptc_add(h, proto, prx_addr, srv_addr, out_ip);
        if (ret < 0) {
            iptc_free(h);
            return ret;
        }
    }

    ret = iptc_commit(h);
    if (ret <= 0) {
        printf( "IPTC_COMMIT_ERROR [%d:%s]", ret, iptc_strerror(errno));
    }
    iptc_free(h);
    return ret;
}

int  main(int argc, char **argv){
    if(argc < 6){
        printf("./my_iptable porxyIp  proxyPort servIp servPort outIp protocol\n");
        return 0;
    }
    my_addr prx_addr;
    my_addr srv_addr;
    my_sock_addr(argv[1],atoi(argv[2]),&prx_addr);
    my_sock_addr(argv[3],atoi(argv[4]),&srv_addr);

    unsigned int out_ip = inet_addr(argv[5]);

    iptc_operate('A',&srv_addr,&prx_addr,out_ip,argv[6]);

    return 1;
}

struct ipt_entry {
    struct ipt_ip ip;  //  通用的匹配规则

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

    /* Size of ipt_entry + matches */
    u_int16_t target_offset;  // 偏移量 指向规则target模块内容
    /* Size of ipt_entry + matches + target */
    u_int16_t next_offset; //  偏移量  指向下一个规则

    /* Back pointer */
    unsigned int comefrom;

    /* Packet and byte counters. */
    struct xt_counters counters; // 统计计算一条链过滤了packet 数目 ，和字节

    /* The matches (if any), then the target. */
    unsigned char elems[0];  // 可变数组，有match 模块，target模块可变数据内容就会包含这两模块
};

#define ipt_entry_match xt_entry_match
#define ipt_entry_target xt_entry_target

struct xt_entry_match {
    union {
        struct {
            __u16 match_size;  

            /* Used by userspace */
            char name[XT_FUNCTION_MAXNAMELEN-1];

            __u8 revision;
        } user;
        struct {
            __u16 match_size;

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

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

    unsigned char data[0];
};

struct xt_entry_target {
    union {
        struct {
            __u16 target_size;

            /* Used by userspace */
            char name[XT_FUNCTION_MAXNAMELEN-1];

            __u8 revision;
        } user;
        struct {
            __u16 target_size;

            /* Used inside the kernel */
            struct xt_target *target;
        } kernel;

        /* Total length */
        __u16 target_size;
    } u;

    unsigned char data[0];
};