IPV6 实现
看代码实现前，请先保证了解ipv6的概念，可以先看ipv6介绍一文。
code extract from 2.6..
在文件 net/ipv6/af_inet6.c 中包含了ipv6协议初始化的主函数。
static int __init inet6_init(void)
{
struct sk_buff *dummy_skb;
struct list_head *r;
int err;
//inet6_skb_parm必须小于等于skb中的cb
BUILD_BUG_ON(sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb)); //初始化tcpv6_prot结构中的一些与slab相关的字段，然后添加到 proto_list 全局连表
err = proto_register(&tcpv6_prot, );
if (err)
goto out;
//udp协议同上
err = proto_register(&udpv6_prot, );
if (err)
goto out_unregister_tcp_proto;
//udp-lite传输协议，主要用于多媒体传输，参考kernel中的 Documentation/networking/udplite.txt
err = proto_register(&udplitev6_prot, );
if (err)
goto out_unregister_udp_proto;
//原始套接字同上
err = proto_register(&rawv6_prot, );
if (err)
goto out_unregister_udplite_proto; /* Register the socket-side information for inet6_create. */
for(r = &inetsw6[]; r < &inetsw6[SOCK_MAX]; ++r) //初始化一个协议连表数组
INIT_LIST_HEAD(r);
/* We MUST register RAW sockets before we create the ICMP6, IGMP6, or NDISC control sockets. */
//根据参数数据结构中标识的协议类型，把这数据结构添加到上面的协议连表数组中
inet6_register_protosw(&rawv6_protosw); /* Register the family here so that the init calls below will be able to create sockets. (?? is this dangerous ??) */
//注册ipv6协议族，主要是注册socket创建函数
err = sock_register(&inet6_family_ops);
if (err)
goto out_unregister_raw_proto; /* Initialise ipv6 mibs */
err = init_ipv6_mibs(); //所有ipv6相关的统计信息
if (err)
goto out_unregister_sock;
/* ipngwg API draft makes clear that the correct semantics for TCP and UDP is to consider one TCP and UDP instance in a host availiable by both INET and INET6 APIs and able to communicate via both network protocols. */
#ifdef CONFIG_SYSCTL
ipv6_sysctl_register(); // ipv6协议proc条件项初始化
#endif
//icmp协议注册
err = icmpv6_init(&inet6_family_ops);
if (err)
goto icmp_fail;
//邻居协议（arp）初始化
err = ndisc_init(&inet6_family_ops);
if (err)
goto ndisc_fail;
//igmp协议初始化
err = igmp6_init(&inet6_family_ops);
if (err)
goto igmp_fail;
//ipv6协议相关的 netfilter 初始化
err = ipv6_netfilter_init();
if (err)
goto netfilter_fail; /* Create /proc/foo6 entries. */
#ifdef CONFIG_PROC_FS //注册/proc/中协议统计输出项
err = -ENOMEM;
if (raw6_proc_init())
goto proc_raw6_fail;
if (tcp6_proc_init())
goto proc_tcp6_fail;
if (udp6_proc_init())
goto proc_udp6_fail;
if (udplite6_proc_init())
goto proc_udplite6_fail;
if (ipv6_misc_proc_init())
goto proc_misc6_fail;
if (ac6_proc_init())
goto proc_anycast6_fail;
if (if6_proc_init())
goto proc_if6_fail;
#endif
ip6_route_init(); //ipv6 路由初始化
ip6_flowlabel_init();//ipv6 中流标记，注册了输出流标记的 proc //rtnetlink相关部分和路由模板中一些字段和其他一些功能的初始化
err = addrconf_init();
if (err)
goto addrconf_fail;
/* Init v6 extension headers. */
//ipv6 新添加的扩展头初始化，参考ipv6介绍
ipv6_rthdr_init();
ipv6_frag_init();
ipv6_nodata_init();
ipv6_destopt_init(); /* Init v6 transport protocols. */
//最主要的传输层协议初始化
udpv6_init();
udplitev6_init();
tcpv6_init(); //最后注册ipv6协议，注册协议处理函数
ipv6_packet_init();
err = ;
out:
return err;
...... //下面就是错误处理的过程
}
下面我们主要看ipv6协议部分流程，其他部分在各自相关文章中介绍。
ipv6扩展头，路由包头注册
void __init ipv6_rthdr_init(void)
{
if (inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING) < )
printk(KERN_ERR "ipv6_rthdr_init: Could not register protocol\n");
};
ipv6扩展头，分片包头注册
void __init ipv6_frag_init(void)
{
if (inet6_add_protocol(&frag_protocol, IPPROTO_FRAGMENT) < )
printk(KERN_ERR "ipv6_frag_init: Could not register protocol\n"); ip6_frags.ctl = &ip6_frags_ctl;
ip6_frags.hashfn = ip6_hashfn;
ip6_frags.constructor = ip6_frag_init;
ip6_frags.destructor = NULL;
ip6_frags.skb_free = NULL;
ip6_frags.qsize = sizeof(struct frag_queue);
ip6_frags.match = ip6_frag_match;
ip6_frags.frag_expire = ip6_frag_expire;
inet_frags_init(&ip6_frags);
}
void __init ipv6_nodata_init(void)
{
if (inet6_add_protocol(&nodata_protocol, IPPROTO_NONE) < )
printk(KERN_ERR "ipv6_nodata_init: Could not register protocol\n");
}
ipv6扩展头，目的选项包头注册
void __init ipv6_destopt_init(void)
{
if (inet6_add_protocol(&destopt_protocol, IPPROTO_DSTOPTS) < )
printk(KERN_ERR "ipv6_destopt_init: Could not register protocol\n");
}
注册ipv6协议处理函数
void __init ipv6_packet_init(void)
{
dev_add_pack(&ipv6_packet_type);
}
当netif_receive_skb函数向上层递交skb时会根据协议类型调用相关的协议处理函数，那么就会调用到 ipv6_rcv函数了。
static struct packet_type ipv6_packet_type = {
.type = __constant_htons(ETH_P_IPV6),
.func = ipv6_rcv,
.gso_send_check = ipv6_gso_send_check,
.gso_segment = ipv6_gso_segment,
};
ipv6协议处理函数
int ipv6_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
{
struct ipv6hdr *hdr;
u32 pkt_len;
struct inet6_dev *idev; if (dev->nd_net != &init_net) {
kfree_skb(skb);
return ;
}
//mac地址是其他主机的包
if (skb->pkt_type == PACKET_OTHERHOST) {
kfree_skb(skb);
return ;
}
rcu_read_lock();
//获取ipv6相关的配置结构
idev = __in6_dev_get(skb->dev); IP6_INC_STATS_BH(idev, IPSTATS_MIB_INRECEIVES);
//是否共享，如果是，新clone一个
if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) {
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INDISCARDS);
rcu_read_unlock();
goto out;
}
//清空保存扩展头解析结果的数据结构
memset(IP6CB(skb), , sizeof(struct inet6_skb_parm)); //保存接收这个数据包的设备索引
IP6CB(skb)->iif = skb->dst ? ip6_dst_idev(skb->dst)->dev->ifindex : dev->ifindex; //有足够的头长度，ipv6是40字节
if (unlikely(!pskb_may_pull(skb, sizeof(*hdr))))
goto err; hdr = ipv6_hdr(skb); //获取头 if (hdr->version != ) //验证版本
goto err; //传输头（扩展头）在网络头后面
skb->transport_header = skb->network_header + sizeof(*hdr);
//保存下一个扩展头协议在ipv6头结构中的偏移
IP6CB(skb)->nhoff = offsetof(struct ipv6hdr, nexthdr);
pkt_len = ntohs(hdr->payload_len); //ipv6负载数据长度 /* pkt_len may be zero if Jumbo payload option is present */
if (pkt_len || hdr->nexthdr != NEXTHDR_HOP) { //没有使用扩展头逐个跳段选项
if (pkt_len + sizeof(struct ipv6hdr) > skb->len) { //数据长度不对
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INTRUNCATEDPKTS);
goto drop;
}
//如果skb->len > (pkt_len + sizeof(struct ipv6hdr))试着缩小skb->len的长度
//相对ipv4来说简单多了，自己看吧
if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr))) {
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INHDRERRORS);
goto drop;
}
hdr = ipv6_hdr(skb); //重新获取ip头
}
if (hdr->nexthdr == NEXTHDR_HOP) { //使用了扩展头逐个跳段选项
if (ipv6_parse_hopopts(skb) < ) {//处理这个选项
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INHDRERRORS);
rcu_read_unlock();
return ;
}
}
rcu_read_unlock();
//进入ipv6的netfilter然后调用ip6_rcv_finish
return NF_HOOK(PF_INET6,NF_IP6_PRE_ROUTING, skb, dev, NULL, ip6_rcv_finish);
err:
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INHDRERRORS);
drop:
rcu_read_unlock();
kfree_skb(skb);
out:
return ;
}
解析扩展头逐个跳段中的巨量负载选项
int ipv6_parse_hopopts(struct sk_buff *skb)
{
struct inet6_skb_parm *opt = IP6CB(skb); //获取扩展头结果结构
/* skb_network_header(skb) is equal to skb->data, and skb_network_header_len(skb) is always equal to * sizeof(struct ipv6hdr) by definition of hop-by-hop options. */
//验证数据有足够的长度
if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + ) || !pskb_may_pull(skb, (sizeof(struct ipv6hdr) +
//下面的意思是取得扩展首部中的长度
((skb_transport_header(skb)[] + ) << )))) {
kfree_skb(skb);
return -;
}
opt->hop = sizeof(struct ipv6hdr); //40字节
if (ip6_parse_tlv(tlvprochopopt_lst, skb)) { //实际的解析工作
//把传输头移动到扩展首部之后
skb->transport_header += (skb_transport_header(skb)[] + ) << ;
opt = IP6CB(skb);
opt->nhoff = sizeof(struct ipv6hdr); //进行了ipv6扩展头解析，保存下一个扩展头协议字段的偏移
return ;
}
return -;
}
解析tlv编码的扩展选项头
static int ip6_parse_tlv(struct tlvtype_proc *procs, struct sk_buff *skb)
{
struct tlvtype_proc *curr;
const unsigned char *nh = skb_network_header(skb); //获取网络头
int off = skb_network_header_len(skb); //获取网络头长度
int len = (skb_transport_header(skb)[] + ) << ; //首部扩展头长度 if (skb_transport_offset(skb) + len > skb_headlen(skb)) //长度错误
goto bad;
off += ; //跳过下一个首部和首部扩展长度这两个字节
len -= ; while (len > ) {
int optlen = nh[off + ] + ; //获取选项数据长度 + 2 (2是选项类型和选项数据长度两字节)
switch (nh[off]) { //选项类型
case IPV6_TLV_PAD0: //Pad1选项
optlen = ;
break;
case IPV6_TLV_PADN://PadN选项
break;
default: //其他选项
if (optlen > len)
goto bad; for (curr = procs; curr->type >= ; curr++) {
if (curr->type == nh[off]) { //类型匹配，调用参数函数处理，参考下面ipv6选项处理
/* type specific length/alignment checks will be performed in the func(). */
if (curr->func(skb, off) == )
return ;
break;
}
}
if (curr->type < ) {
if (ip6_tlvopt_unknown(skb, off) == ) //处理未知选项
return ;
}
break;
}
off += optlen; //偏移增加，这样到下一个选项
len -= optlen; //长度递减
}
if (len == )
return ; //正确解析完毕
bad:
kfree_skb(skb);
return ;
}
处理未知的选项
static int ip6_tlvopt_unknown(struct sk_buff *skb, int optoff)
{
//根据选项类型标识符的要求进行处理
switch ((skb_network_header(skb)[optoff] & 0xC0) >> ) {
case : /* ignore */
return ;
case : /* drop packet */
break;
case : /* Send ICMP if not a multicast address and drop packet */
/* Actually, it is redundant check. icmp_send will recheck in any case. */
if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) //目的是多播地址
break;
case : /* send ICMP PARM PROB regardless and drop packet */
//给包的源地址发送一个 ICMP "参数存在问题", 编码 2 的报文, 指针指向无法识别的选项类型
icmpv6_param_prob(skb, ICMPV6_UNK_OPTION, optoff);
return ;
}
kfree_skb(skb);
return ;
}
到这需要解释一下，上面解析ipv6选项只是解析了第一层的扩展头，在后面可能还有其他扩展头会在后面解析。
inline int ip6_rcv_finish( struct sk_buff *skb)
{
if (skb->dst == NULL) //没有路由，进行路由查找
ip6_route_input(skb); //路由部分将在路由实现文章中介绍 return dst_input(skb);
}
static inline int dst_input(struct sk_buff *skb)
{
int err;
for (;;) {
err = skb->dst->input(skb); //调用路由的输入函数
if (likely(err == ))
return err; /* Oh, Jamal... Seems, I will not forgive you this mess. :-) */
if (unlikely(err != NET_XMIT_BYPASS))
return err;
}
}
现在我们假设包是到本地的，那么上面的input函数就是
int ip6_input(struct sk_buff *skb)
{
//进入ipv6 netfilter NF_IP6_LOCAL_IN hook 然后调用 ip6_input_finish
return NF_HOOK(PF_INET6, NF_IP6_LOCAL_IN, skb, skb->dev, NULL, ip6_input_finish);
}
static int ip6_input_finish(struct sk_buff *skb)
{
struct inet6_protocol *ipprot;
struct sock *raw_sk;
unsigned int nhoff;
int nexthdr;
u8 hash;
struct inet6_dev *idev; /* Parse extension headers */
rcu_read_lock();
resubmit:
idev = ip6_dst_idev(skb->dst);
//将skb->data指针移动到传输层头
if (!pskb_pull(skb, skb_transport_offset(skb)))
goto discard; nhoff = IP6CB(skb)->nhoff;
nexthdr = skb_network_header(skb)[nhoff];//下一个扩展头协议 //处理原始sock
raw_sk = sk_head(&raw_v6_htable[nexthdr & (MAX_INET_PROTOS - )]);
if (raw_sk && !ipv6_raw_deliver(skb, nexthdr))
raw_sk = NULL; //向上层协议栈递交数据，看初始化时注册的一些协议，主要是tcp，udp等，还包括一些ip扩展头的处理
hash = nexthdr & (MAX_INET_PROTOS - );
if ((ipprot = rcu_dereference(inet6_protos[hash])) != NULL) {
int ret;
if (ipprot->flags & INET6_PROTO_FINAL) {
struct ipv6hdr *hdr;
/* Free reference early: we don't need it any more,
and it may hold ip_conntrack module loaded indefinitely. */
nf_reset(skb); skb_postpull_rcsum(skb, skb_network_header(skb), skb_network_header_len(skb));
hdr = ipv6_hdr(skb);
if (ipv6_addr_is_multicast(&hdr->daddr) && !ipv6_chk_mcast_addr(skb->dev, &hdr->daddr, &hdr->saddr)
&& !ipv6_is_mld(skb, nexthdr))
goto discard;
}
//处理 IPSEC v6 的相关部分
if (!(ipprot->flags & INET6_PROTO_NOPOLICY) && !xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
goto discard; ret = ipprot->handler(skb); //上层协议处理，看下面ipv6扩展头处理
if (ret > )
goto resubmit; //重新处理
else if (ret == )
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INDELIVERS);
} else { //没有找到上层处理函数
if (!raw_sk) {
if (xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INUNKNOWNPROTOS);
icmpv6_send(skb, ICMPV6_PARAMPROB, ICMPV6_UNK_NEXTHDR, nhoff, skb->dev);
}
} else
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INDELIVERS);
kfree_skb(skb);
}
rcu_read_unlock();
return ;
discard:
IP6_INC_STATS_BH(idev, IPSTATS_MIB_INDISCARDS);
rcu_read_unlock();
kfree_skb(skb);
return ;
} [ipv6选项处理]
static struct tlvtype_proc tlvprochopopt_lst[] = {
{
.type = IPV6_TLV_ROUTERALERT,
.func = ipv6_hop_ra,
},
{
.type = IPV6_TLV_JUMBO,
.func = ipv6_hop_jumbo,
},
{ -, }
};
解析路由警告选项
static int ipv6_hop_ra(struct sk_buff *skb, int optoff)
{
const unsigned char *nh = skb_network_header(skb); //获取网络头 if (nh[optoff + ] == ) { //路由警告选项长度必须是2 ? rfc 要求是 4
IP6CB(skb)->ra = optoff; //记录警告类型
return ;
}
LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_ra: wrong RA length %d\n", nh[optoff + ]);
kfree_skb(skb);
return ;
}
解析jumbo frame选项
static int ipv6_hop_jumbo(struct sk_buff *skb, int optoff)
{
const unsigned char *nh = skb_network_header(skb);
u32 pkt_len;
//选项数据长度必须是4，选项类型必须是 0xc2， ＆3 后必须是2
if (nh[optoff + ] != || (optoff & ) != ) {
LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n", nh[optoff+]);
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INHDRERRORS);
goto drop;
}
pkt_len = ntohl(*(__be32 *)(nh + optoff + )); //获取整个负载长度
if (pkt_len <= IPV6_MAXPLEN) { //小于65535 是不对地
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff+);
return ;
}
if (ipv6_hdr(skb)->payload_len) { //原ipv6头中就不应该有负载长度了
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff);
return ;
}
if (pkt_len > skb->len - sizeof(struct ipv6hdr)) { //长度超出了 skb 的实际长度
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INTRUNCATEDPKTS);
goto drop;
}
//如果必要试图缩减 skb 的长度
if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr)))
goto drop; return ;
drop:
kfree_skb(skb);
return ;
}
目的选项处理
static struct tlvtype_proc tlvprocdestopt_lst[] = {
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
{
.type = IPV6_TLV_HAO,
.func = ipv6_dest_hao,
},
#endif
{-, NULL}
};
解析目的选项
static int ipv6_dest_hao(struct sk_buff *skb, int optoff)
{
struct ipv6_destopt_hao *hao;
struct inet6_skb_parm *opt = IP6CB(skb);
struct ipv6hdr *ipv6h = ipv6_hdr(skb);
struct in6_addr tmp_addr;
int ret; if (opt->dsthao) { //已经处理
LIMIT_NETDEBUG(KERN_DEBUG "hao duplicated\n");
goto discard;
}
opt->dsthao = opt->dst1;
opt->dst1 = ; //获取网络头后面的选项部分
hao = (struct ipv6_destopt_hao *)(skb_network_header(skb) + optoff); if (hao->length != ) { //长度要求
LIMIT_NETDEBUG(KERN_DEBUG "hao invalid option length = %d\n", hao->length);
goto discard;
}
if (!(ipv6_addr_type(&hao->addr) & IPV6_ADDR_UNICAST)) { //地址不是单播
LIMIT_NETDEBUG(KERN_DEBUG "hao is not an unicast addr: " NIP6_FMT "\n", NIP6(hao->addr));
goto discard;
}
//IPSEC相关
ret = xfrm6_input_addr(skb, (xfrm_address_t *)&ipv6h->daddr, (xfrm_address_t *)&hao->addr, IPPROTO_DSTOPTS);
if (unlikely(ret < ))
goto discard; if (skb_cloned(skb)) { //如果包是cloned
//分配新的内存数据
if (pskb_expand_head(skb, , , GFP_ATOMIC))
goto discard; //重新指向各头
hao = (struct ipv6_destopt_hao *)(skb_network_header(skb) + optoff);
ipv6h = ipv6_hdr(skb);
}
if (skb->ip_summed == CHECKSUM_COMPLETE)
skb->ip_summed = CHECKSUM_NONE; //把ip头中的源地址与选项中的地址交换
ipv6_addr_copy(&tmp_addr, &ipv6h->saddr);
ipv6_addr_copy(&ipv6h->saddr, &hao->addr);
ipv6_addr_copy(&hao->addr, &tmp_addr); if (skb->tstamp.tv64 == )
__net_timestamp(skb); //记录时间截 return ;
discard:
kfree_skb(skb);
return ;
}
[/ipv6选项处理]
[ipv6扩展头处理]
我们只介绍根ipv6扩展头相关的实现，像其他的扩展头(tcp, udp)等虽然也是叫扩展头但实际是传输层的内容，将在其他文章中介绍。
路由扩展首部
struct ipv6_rt_hdr {
__u8 nexthdr;
__u8 hdrlen;
__u8 type;
__u8 segments_left; /* type specific data variable length field */
};
路由扩展首部处理结构
static struct inet6_protocol rthdr_protocol = {
.handler = ipv6_rthdr_rcv,
.flags = INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
};
static int ipv6_rthdr_rcv(struct sk_buff *skb)
{
struct inet6_skb_parm *opt = IP6CB(skb);
struct in6_addr *addr = NULL;
struct in6_addr daddr;
struct inet6_dev *idev;
int n, i;
struct ipv6_rt_hdr *hdr;
struct rt0_hdr *rthdr;
int accept_source_route = ipv6_devconf.accept_source_route; idev = in6_dev_get(skb->dev); //包进入设备
if (idev) {
if (accept_source_route > idev->cnf.accept_source_route) //默认数量大于了手动调节(proc中）的数量
accept_source_route = idev->cnf.accept_source_route;
in6_dev_put(idev);
}
//skb长度和内存空间正确
if (!pskb_may_pull(skb, skb_transport_offset(skb) + ) || !pskb_may_pull(skb, (skb_transport_offset(skb) +
((skb_transport_header(skb)[] + ) << )))) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
kfree_skb(skb);
return -;
}
hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb); //路由扩展头
//是到多播地址或硬件地址不是到本机的地址
if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) || skb->pkt_type != PACKET_HOST) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
kfree_skb(skb);
return -;
}
looped_back:
if (hdr->segments_left == ) { //根据rfc要求 分段剩余为0
switch (hdr->type) {
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
case IPV6_SRCRT_TYPE_2:
/* Silently discard type 2 header unless it was processed by own */
if (!addr) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
kfree_skb(skb);
return -;
}
break;
#endif
default:
break; }
opt->lastopt = opt->srcrt = skb_network_header_len(skb);
skb->transport_header += (hdr->hdrlen + ) << ; //下一个传输头的位置
opt->dst0 = opt->dst1;
opt->dst1 = ;
opt->nhoff = (&hdr->nexthdr) - skb_network_header(skb); //记录下一个头数据相对网络头的偏移量
return ;
}
switch (hdr->type) {
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
case IPV6_SRCRT_TYPE_2:
if (accept_source_route < )
goto unknown_rh;
/* Silently discard invalid RTH type 2 */
if (hdr->hdrlen != || hdr->segments_left != ) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
kfree_skb(skb);
return -;
}
break;
#endif
default:
goto unknown_rh;
}
/* This is the routing header forwarding algorithm from RFC 2460, page 16. */ n = hdr->hdrlen >> ; //计算路由首部中的地址数量
if (hdr->segments_left > n) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, ((&hdr->segments_left) - skb_network_header(skb)));
return -;
}
/* We are about to mangle packet header. Be careful!
Do not damage packets queued somewhere. */
if (skb_cloned(skb)) {
/* the copy is a forwarded packet */
if (pskb_expand_head(skb, , , GFP_ATOMIC)) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_OUTDISCARDS);
kfree_skb(skb);
return -;
}
hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb);
}
if (skb->ip_summed == CHECKSUM_COMPLETE)
skb->ip_summed = CHECKSUM_NONE; i = n - --hdr->segments_left; //计算地址向量(地址列表)中要"访问"的下一个地址 rthdr = (struct rt0_hdr *) hdr;
addr = rthdr->addr; //指向地址列表首部
addr += i - ; //移动到下一个地址 switch (hdr->type) {
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
case IPV6_SRCRT_TYPE_2:
if (xfrm6_input_addr(skb, (xfrm_address_t *)addr, (xfrm_address_t *)&ipv6_hdr(skb)->saddr, IPPROTO_ROUTING) < ) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
kfree_skb(skb);
return -;
}
if (!ipv6_chk_home_addr(addr)) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
kfree_skb(skb);
return -;
}
break;
#endif
default:
break;
}
if (ipv6_addr_is_multicast(addr)) { //这个地址是多播地址
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INADDRERRORS);
kfree_skb(skb);
return -;
}
//交换 IPv6 目的地址和这个地址
ipv6_addr_copy(&daddr, addr);
ipv6_addr_copy(addr, &ipv6_hdr(skb)->daddr);
ipv6_addr_copy(&ipv6_hdr(skb)->daddr, &daddr);
dst_release(xchg(&skb->dst, NULL)); ip6_route_input(skb); //路由查找处理，将在其他文章中介绍 if (skb->dst->error) {
skb_push(skb, skb->data - skb_network_header(skb));
dst_input(skb);
return -;
} if (skb->dst->dev->flags & IFF_LOOPBACK) { //路由查找后要发送到的目的设备是回环
if (ipv6_hdr(skb)->hop_limit <= ) { //跳数限制小于1
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
//给源地址发送一个 ICMP "超时 – 传输超过跳数限制" 的报文, 并且抛弃此包
icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, , skb->dev);
kfree_skb(skb);
return -;
}
ipv6_hdr(skb)->hop_limit--;
goto looped_back;
}
//将data之中移动到网络头
skb_push(skb, skb->data - skb_network_header(skb));
dst_input(skb); //这时包应该被转发了
return -;
unknown_rh:
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, (&hdr->type) - skb_network_header(skb));
return -;
}
ipv6分配包扩展首部处理
static struct inet6_protocol frag_protocol =
{
.handler = ipv6_frag_rcv,
.flags = INET6_PROTO_NOPOLICY,
};
static int ipv6_frag_rcv(struct sk_buff *skb)
{
struct frag_hdr *fhdr;
struct frag_queue *fq;
struct ipv6hdr *hdr = ipv6_hdr(skb); IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMREQDS); /* Jumbo payload inhibits frag. header */
if (hdr->payload_len == ) { //是Jumbo payload，不是分片包
IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, skb_network_header_len(skb));
return -;
}
//有碎片头空间
if (!pskb_may_pull(skb, (skb_transport_offset(skb) + sizeof(struct frag_hdr)))) {
IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, skb_network_header_len(skb));
return -;
}
hdr = ipv6_hdr(skb);
fhdr = (struct frag_hdr *)skb_transport_header(skb); //分片头 if (!(fhdr->frag_off & htons(0xFFF9))) { //没有分片偏移，不是分片包
/* It is not a fragmented frame */
skb->transport_header += sizeof(struct frag_hdr); //传输头向后移动到下一个头
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMOKS);
IP6CB(skb)->nhoff = (u8 *)fhdr - skb_network_header(skb);
return ;
}
if (atomic_read(&ip6_frags.mem) > ip6_frags_ctl.high_thresh) //内存使用超过限制
ip6_evictor(ip6_dst_idev(skb->dst)); //查找或创建分片队列头
if ((fq = fq_find(fhdr->identification, &hdr->saddr, &hdr->daddr, ip6_dst_idev(skb->dst))) != NULL) {
int ret;
spin_lock(&fq->q.lock);
ret = ip6_frag_queue(fq, skb, fhdr, IP6CB(skb)->nhoff); //入队重组
spin_unlock(&fq->q.lock);
fq_put(fq);
return ret;
}
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMFAILS);
kfree_skb(skb);
return -;
}
static __inline__ struct frag_queue * fq_find(__be32 id, struct in6_addr *src, struct in6_addr *dst, struct inet6_dev *idev)
{
struct inet_frag_queue *q;
struct ip6_create_arg arg;
unsigned int hash; arg.id = id;
arg.src = src;
arg.dst = dst;
hash = ip6qhashfn(id, src, dst); //id，源，目的进行 hash q = inet_frag_find(&ip6_frags, &arg, hash); //查找或创建
if (q == NULL)
goto oom; return container_of(q, struct frag_queue, q); //成功返回
oom: //没内存了
IP6_INC_STATS_BH(idev, IPSTATS_MIB_REASMFAILS);
return NULL;
}
struct inet_frag_queue *inet_frag_find(struct inet_frags *f, void *key, unsigned int hash)
{
struct inet_frag_queue *q;
struct hlist_node *n; read_lock(&f->lock);
hlist_for_each_entry(q, n, &f->hash[hash], list) { //在hash桶中查找 if (f->match(q, key)) { //调用匹配函数进行匹配，具体函数很简单参考初始化时的ipv6_frag_init函数
atomic_inc(&q->refcnt);
read_unlock(&f->lock);
return q;
}
}
//没有找到就创建一个
return inet_frag_create(f, key, hash);
}
创建分片队列
static struct inet_frag_queue *inet_frag_create(struct inet_frags *f, void *arg, unsigned int hash)
{
struct inet_frag_queue *q; q = inet_frag_alloc(f, arg); //分配一个
if (q == NULL)
return NULL;
//添加到 hash 表
return inet_frag_intern(q, f, hash, arg);
}
static struct inet_frag_queue *inet_frag_alloc(struct inet_frags *f, void *arg)
{
struct inet_frag_queue *q; q = kzalloc(f->qsize, GFP_ATOMIC); //分配一个队列头，大小是 sizeof(struct frag_queue)
if (q == NULL)
return NULL; f->constructor(q, arg); //拷贝地址和 id 到队列头结构中
atomic_add(f->qsize, &f->mem);
setup_timer(&q->timer, f->frag_expire, (unsigned long)q);
spin_lock_init(&q->lock);
atomic_set(&q->refcnt, );
return q;
}
static struct inet_frag_queue *inet_frag_intern(struct inet_frag_queue *qp_in, struct inet_frags *f, unsigned int hash, void *arg)
{
struct inet_frag_queue *qp;
#ifdef CONFIG_SMP
struct hlist_node *n;
#endif write_lock(&f->lock);
#ifdef CONFIG_SMP
//其他cpu可能已经创建了一个，所以要再次检查
hlist_for_each_entry(qp, n, &f->hash[hash], list) {
if (f->match(qp, arg)) { //已经创建
atomic_inc(&qp->refcnt);
write_unlock(&f->lock);
qp_in->last_in |= COMPLETE;
inet_frag_put(qp_in, f); //释放新分配的
return qp; }
}
#endif
qp = qp_in;
if (!mod_timer(&qp->timer, jiffies + f->ctl->timeout)) //启动定时器
atomic_inc(&qp->refcnt); //增加引用计数，然后添加到hash表
atomic_inc(&qp->refcnt);
hlist_add_head(&qp->list, &f->hash[hash]);
list_add_tail(&qp->lru_list, &f->lru_list);
f->nqueues++;
write_unlock(&f->lock);
return qp;
}
入队重组
static int ip6_frag_queue(struct frag_queue *fq, struct sk_buff *skb, struct frag_hdr *fhdr, int nhoff)
{
struct sk_buff *prev, *next;
struct net_device *dev;
int offset, end; if (fq->q.last_in & COMPLETE) //重组已经完成
goto err; //分片开始位置
offset = ntohs(fhdr->frag_off) & ~0x7;//偏移必须8字节对齐
//分片在整个包中的结束位置 包负载长度 - 分片头长度
end = offset + (ntohs(ipv6_hdr(skb)->payload_len) - ((u8 *)(fhdr + ) - (u8 *)(ipv6_hdr(skb) + ))); //结束位置 > 65535
if ((unsigned int)end > IPV6_MAXPLEN) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, ((u8 *)&fhdr->frag_off - skb_network_header(skb)));
return -;
}
//校验和已经完成
if (skb->ip_summed == CHECKSUM_COMPLETE) {
const unsigned char *nh = skb_network_header(skb);
//减去分片包头的校验和
skb->csum = csum_sub(skb->csum, csum_partial(nh, (u8 *)(fhdr + ) - nh, ));
}
//最后一个碎片包
if (!(fhdr->frag_off & htons(IP6_MF))) {
/* If we already have some bits beyond end or have different end, the segment is corrupted. */
if (end < fq->q.len || ((fq->q.last_in & LAST_IN) && end != fq->q.len)) //分片出现错误
goto err; fq->q.last_in |= LAST_IN; //标识最后一个分片
fq->q.len = end; //记录包总长度
} else {
/* Check if the fragment is rounded to 8 bytes. Required by the RFC. */
if (end & 0x7) { //碎片结尾也需要8字节对齐
/* RFC2460 says always send parameter problem in this case. -DaveM */
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), PSTATS_MIB_INHDRERRORS);
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, offsetof(struct ipv6hdr, payload_len));
return -;
}
if (end > fq->q.len) {
/* Some bits beyond end -> corruption. */
if (fq->q.last_in & LAST_IN)
goto err;
fq->q.len = end; //记录已经得到的碎片的最大长度
}
}
if (end == offset) //开始 = 结束
goto err; //skb->data 指向碎片首部头后数据部分
if (!pskb_pull(skb, (u8 *) (fhdr + ) - skb->data))
goto err;
//如果需要缩短skb的内存长度
if (pskb_trim_rcsum(skb, end - offset))
goto err; //找出碎片所在位置
prev = NULL;
for(next = fq->q.fragments; next != NULL; next = next->next) {
if (FRAG6_CB(next)->offset >= offset)
break; /* bingo! */
prev = next;
}
if (prev) { //有前一个碎片
//前一个碎片 (开始 + 长度) - 这个碎片的开始. 计算出重叠部分
int i = (FRAG6_CB(prev)->offset + prev->len) - offset;
if (i > ) { //有重叠
offset += i; //调整这个碎片的开始位置
if (end <= offset) //调整后出错
goto err;
if (!pskb_pull(skb, i))//skb->data += i;
goto err;
if (skb->ip_summed != CHECKSUM_UNNECESSARY)
skb->ip_summed = CHECKSUM_NONE;
}
}
//有下一个碎片，且开始位置 < 这个碎片的结束位置
while (next && FRAG6_CB(next)->offset < end) {
//这个碎片的结束位置 - 下一个碎片的开始位置，计算重叠
int i = end - FRAG6_CB(next)->offset; /* overlap is 'i' bytes */
if (i < next->len) { //重叠长度 < 下一个碎片的长度
if (!pskb_pull(next, i)) //next->data += i;
goto err; FRAG6_CB(next)->offset += i; //下一个碎片开始位置调整
fq->q.meat -= i; //总长度减少
if (next->ip_summed != CHECKSUM_UNNECESSARY)
next->ip_summed = CHECKSUM_NONE;
break; } else { //这个碎片完全复盖了下一个碎片
struct sk_buff *free_it = next; //释放这个碎片
next = next->next;//调整下一个碎片指针
//调整队列指针
if (prev)
prev->next = next;
else
fq->q.fragments = next; fq->q.meat -= free_it->len;
frag_kfree_skb(free_it, NULL); //释放被复盖的包
}
}
FRAG6_CB(skb)->offset = offset; //这个碎片包记录自己的开始位置 //插入这个碎片到队列
skb->next = next;
if (prev)
prev->next = skb;
else
fq->q.fragments = skb; dev = skb->dev;
if (dev) {
fq->iif = dev->ifindex;
skb->dev = NULL;
}
fq->q.stamp = skb->tstamp;
fq->q.meat += skb->len; //累加总长度
atomic_add(skb->truesize, &ip6_frags.mem); if (offset == ) { //偏移为0
fq->nhoffset = nhoff;
fq->q.last_in |= FIRST_IN; //标识开始碎片
}
//碎片已经聚齐，记录长度 = 包中标识的长度
if (fq->q.last_in == (FIRST_IN | LAST_IN) && fq->q.meat == fq->q.len)
return ip6_frag_reasm(fq, prev, dev); //重组
//没有聚齐，移动队列连表到lru连表尾部
write_lock(&ip6_frags.lock);
list_move_tail(&fq->q.lru_list, &ip6_frags.lru_list);
write_unlock(&ip6_frags.lock);
return -;
err:
IP6_INC_STATS(ip6_dst_idev(skb->dst), IPSTATS_MIB_REASMFAILS);
kfree_skb(skb);
return -;
}
重组ip头
static int ip6_frag_reasm(struct frag_queue *fq, struct sk_buff *prev, struct net_device *dev)
{
struct sk_buff *fp, *head = fq->q.fragments;
int payload_len;
unsigned int nhoff; fq_kill(fq); //把这个重组队列出队 /* Make the one we just received the head. */
if (prev) {
//下面是把head指向的skb复制到fp，然后把fp插入到head指向的位置
head = prev->next;
fp = skb_clone(head, GFP_ATOMIC); if (!fp)
goto out_oom; fp->next = head->next;
prev->next = fp;
//把真正的头skb复制到head指针的skb
skb_morph(head, fq->q.fragments);
head->next = fq->q.fragments->next; kfree_skb(fq->q.fragments);//释放原来的头
fq->q.fragments = head;
}
/* Unfragmented part is taken from the first segment. */
//计算负载总长度
payload_len = ((head->data - skb_network_header(head)) - sizeof(struct ipv6hdr) + fq->q.len - sizeof(struct frag_hdr));
if (payload_len > IPV6_MAXPLEN) //超过65535
goto out_oversize; /* Head of list must not be cloned. */
//如果skb被克隆，从新分配他的data
if (skb_cloned(head) && pskb_expand_head(head, , , GFP_ATOMIC))
goto out_oom; /* If the first fragment is fragmented itself, we split it to two chunks: the first with data and paged part * and the second, holding only fragments. */
if (skb_shinfo(head)->frag_list) {//如果头自己已经被分片
struct sk_buff *clone;
int i, plen = ; if ((clone = alloc_skb(, GFP_ATOMIC)) == NULL)
goto out_oom; //把这个clone插入到头后
clone->next = head->next;
head->next = clone;
//把头的分片给这个clone
skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list;
skb_shinfo(head)->frag_list = NULL;
//头使用了页面，计算总长度
for (i = ; i < skb_shinfo(head)->nr_frags; i++)
plen += skb_shinfo(head)->frags[i].size; clone->len = clone->data_len = head->data_len - plen;
head->data_len -= clone->len;
head->len -= clone->len;
clone->csum = ;
clone->ip_summed = head->ip_summed;
atomic_add(clone->truesize, &ip6_frags.mem);
}
/* We have to remove fragment header from datagram and to relocate
* header in order to calculate ICV correctly. */
nhoff = fq->nhoffset;
//把传输头（分片头）中的下一个头字段值赋给网络头中的下一个头字段
skb_network_header(head)[nhoff] = skb_transport_header(head)[];
//把分片首部复盖掉
memmove(head->head + sizeof(struct frag_hdr), head->head, (head->data - head->head) - sizeof(struct frag_hdr));
//调整相应的各个层的头位置
head->mac_header += sizeof(struct frag_hdr);
head->network_header += sizeof(struct frag_hdr); skb_shinfo(head)->frag_list = head->next; //保存碎片连表
skb_reset_transport_header(head);//重新调整网络头，现在指向分片头后的头
skb_push(head, head->data - skb_network_header(head));//使head->data指向网络头
atomic_sub(head->truesize, &ip6_frags.mem); for (fp = head->next; fp; fp = fp->next) { //统计分片总长度
head->data_len += fp->len;
head->len += fp->len;
if (head->ip_summed != fp->ip_summed)
head->ip_summed = CHECKSUM_NONE;
else if (head->ip_summed == CHECKSUM_COMPLETE)
head->csum = csum_add(head->csum, fp->csum); //添加各分片的累加和 head->truesize += fp->truesize;
atomic_sub(fp->truesize, &ip6_frags.mem);
}
head->next = NULL;
head->dev = dev;
head->tstamp = fq->q.stamp;
ipv6_hdr(head)->payload_len = htons(payload_len); //总长度
IP6CB(head)->nhoff = nhoff; /* Yes, and fold redundant checksum back. 8) */
if (head->ip_summed == CHECKSUM_COMPLETE) //添加网络头累加和
head->csum = csum_partial(skb_network_header(head), skb_network_header_len(head), head->csum); rcu_read_lock();
IP6_INC_STATS_BH(__in6_dev_get(dev), IPSTATS_MIB_REASMOKS);
rcu_read_unlock();
fq->q.fragments = NULL;
return ;
...... //下面是错误处理
}
无数据扩展头
static struct inet6_protocol nodata_protocol = {
.handler = ipv6_nodata_rcv,
.flags = INET6_PROTO_NOPOLICY,
};
static int ipv6_nodata_rcv(struct sk_buff *skb)
{
kfree_skb(skb);
return ;
}
目的选项首部处理
static struct inet6_protocol destopt_protocol = {
.handler = ipv6_destopt_rcv,
.flags = INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
};
static int ipv6_destopt_rcv(struct sk_buff *skb)
{
struct inet6_skb_parm *opt = IP6CB(skb);
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
__u16 dstbuf;
#endif
struct dst_entry *dst;
//长度验证
if (!pskb_may_pull(skb, skb_transport_offset(skb) + ) || !pskb_may_pull(skb, (skb_transport_offset(skb) +
((skb_transport_header(skb)[] + ) << )))) {
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
kfree_skb(skb);
return -;
}
opt->lastopt = opt->dst1 = skb_network_header_len(skb); //网络头长度
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
dstbuf = opt->dst1;
#endif
dst = dst_clone(skb->dst); //增加dst的引用计数
//解析tlv，上面已经看到过了
if (ip6_parse_tlv(tlvprocdestopt_lst, skb)) {
dst_release(dst);
skb->transport_header += (skb_transport_header(skb)[] + ) << ; //调整网络头位置
opt = IP6CB(skb);
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
opt->nhoff = dstbuf;
#else
opt->nhoff = opt->dst1;
#endif
return ;
}
IP6_INC_STATS_BH(ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS);
dst_release(dst);
return -;
}
[/ipv6扩展头处理]
IPV6 实现的更多相关文章
- App 审核由于 IPv6 网络问题被拒
昨天 提交App Store 的时候被拒了 We discovered one or more bugs in your app when reviewed on iPhone running iOS ...
- iOS 支持 IPv6
苹果的规定:2016年6月1日提交到App Store必须支持IPv6-only网络. 官方文档:https://developer.apple.com/library/mac/documentati ...
- 中大东校小米路由器mini实现inode上网，ipv6 wifi【中大】【东校】【inode】【ipv6】
还有不到4个月就要毕业了,前几天半夜没事捣鼓小米路由没想到竟然实现了wifi的ipv6. 正好又安利了同学一台小米路由mini,从刷机到inode到ipv6全搞了一遍. 这里将教程写出来,服务学弟妹. ...
- IPv6进阶
IPV6报文部分字段介绍 1.没有校验和字段:优点:当TTL减少时,不需要重新处理,相对于IPV4能减少处理的时间:缺点:必须在上层包含校验和2.下一个报文:可指向扩展报文:(大部分节点不处理和查看大 ...
- iOS-不用网线搭建IPv6网络测试环境
前言 从6月1日开始苹果要求之后审核的项目必须支持iPv6,如果不支持将被拒绝,掘金最近一次审核被就被拒绝了....理由为下: Apps are reviewed on an IPv6 network ...
- 通过ipv6访问 g o o g l e
Google.Youtube.Facebook等均支持IPv6访问,IPv4网络的用户大部分都无法访问,比如Gmail,Google Docs等等各种相关服务.而该类网站大部分均已接入IPv6网络,因 ...
- CentOS7中禁用IPV6
helps from: https://linux.cn/article-4935-1.html vi /etc/sysctl.conf net.ipv6.conf.all.disable_ipv6 ...
- IPV6入门篇
引言 由于互联网的快速发展与普及,原有的IPV4地址已不能满足网络用户的需求,虽然NAT可以缓解IPV4地址的耗尽,但NAT破坏了网络环境的开放.透明以及端到端的特性,因此IPV6地址协议应运而生.I ...
- 【ipv6惹的祸】curl 超时
偶然发现 最近在公司日志平台 总是可以看到很多关于php curl的错误信息 Operation timed out after 0 milliseconds with 0 out of 0 byte ...
- 在Linux下禁用IPv6的方法小结
在Linux下禁用IPv6的方法小结--http://www.jb51.net/LINUXjishu/335724.html 这篇文章主要介绍了在Linux下禁用IPv6的方法小结,禁用IPv6的操作 ...
随机推荐
- java struts2自定义调用方法
一个action里面不只会调用一个方法,肯定会用到其他的方法,也写在同一个action里面. 这里不重点讲解了,就直接上代码 struts.xml <?xml version="1.0 ...
- VS 2013 编译和使用 Boost
以 1.58.0 版本 boost 为例, 当前系统版本为 Windows 8.1 x64 1 编译boost 当前解压路径 "D:\Libraries\boost_1_58_0&qu ...
- 百度编辑器1.4.3 .net版在vs2008的使用方法
由于在官方下载的ueditor包是在vs2012下开发的,可以在vs2010中使用,但在vs2008中就会报错.折腾了一翻,现将解决方法分享给需要的朋友,其实就是把里面包含.net4.0的元素换成.n ...
- 首页的sitecontent地址
当无法出现工具栏时,利用url地址,可以方便直接进入sitecontent http://sp2013/sites/bentest/_layouts/15/viewlsts.aspx
- word公式图片显示不全的问题
最近处理文档遇到比较棘手的问题,就是单行显示的公式和图片都显示不全,高度撑不起来,会被其他行的内容遮挡. 图片估计是对齐方式照成的,公式调了很久也没有办法.最后找了一个临时折衷的办法: 插入表格,然后 ...
- LINQ2EF-LINQ2SQL-LINQ笔记
例1:In SQL: AND dep_all_code LIKE '" + depAll + "' AND dep_code in (SELECT DISTINCT DEP3 FR ...
- java之泛型潜在错误
如果使用带泛型声明的类时,没有传入类型参数,那么这个类型参数默认是声明该参数时指定的第一个上限类型,这个类型参数被称为raw type(原始类型 ). eg: public class Lis ...
- HTML教程:link标记
开发php语言的网站,<head>里link标签这样:<link href="xmlrpc.php?rsd=1" title="rsd" ty ...
- rsync 的使用和参数解释
备份往往可以为我们提供一种恢复的策略,因此在实际的生产应用中我们需要对系统的各个配置以及数据进行备份.然而普通的备份都是在本地磁盘或者相应的设备上进行,其实这样也存在一种缺陷,就是设备也出现问题怎么办 ...
- c++与C# winform的消息通讯--（结构体与byte数组的使用）
近期正在做一个蓝牙驱动的使用程序,其中有一块从c++发送数据到C#的部分,网上查了很多资料,大多都是介绍如何通过调用函数获取用户数据.并且在消息发送中,很少介绍如何发送一个结构体,并且结构体里面有 b ...