位置： 首页 > 苏州思科认证 > 张家港思科认证考试科目
张家港思科认证考试科目
预约试听
张家港思科认证考试科目

CCNA  思科认证网络管理员

张家港思科认证考试科目

课程目标：**培训，学员将可以为小型网络安装、配置和运营LAN、WAN和拨号接入业务。

课程特点：理论讲解与动手实践各占一半，讲师以丰富的理论与实践经验帮助学员在短期内吸收课程精华，并能顺利应用到实际当中，胜任工作。

学习内容：思科网络基础，包括设备的装配、布线、操作、配置和管理；Catalyst交换机互連，主要讲述基本交换操作与VLAN配置；思科路由器互連，包括TCP/IP路由、流量管理以及IPX配置；将网络扩展成WAN，包括序列对等连接、ISDN  BRI、帧中继PVC连接。

【教学师资】

张家港思科认证考试科目

杨老师

从业经验：

多年从业经验，对制造业企业网络、金融行业网络、IDC机房、社区宽带网 络及组播、IPV6、MPLS等前沿技术有独特的见解。先后从事大型跨国企业及大型跨国银行网络（如松下、久保田、三菱、三井银行等企业）的规划、建 设、实施和维护工作。针对运营商大客户提出的需求，制定合理的组网方案。 擅长把复杂现网的各种情况融入到课堂的理论讲解之中；对组播和IPv6 等前沿技术有深入的研究。

讲师资质:

深入研究了Cisco和华为两种认证，分别获得两种认证的顶级认证资质： Cisco方向拥有CCIE R&S认证与华为方向拥有HCIE级别认证

授课风格：

深入浅出，风趣幽默，能将多年的实际管理经验和咨询经验融合于课程内容 当中，将枯燥的理论知识与实际案例相结合，使学员在　活泼的气氛当中得到学习；授课内容切中要害、可操作性强。

---路由交换CCNA介绍（CCNA-RS）

张家港思科认证考试科目

1、路由原理复习和加深

2、浮动静态路由的原理和配置

3、递归静态路由的原理和配置

4、RIP协议复习和假声

linux 路由子系统的概要和初始化方法


这里使用linux-3.1.3 ipv4 以太网为例，由于路由子系统的cache部分在**新的内核已经删掉,不再分析这一部分,相应的改动以3.12为参考。
概要
路由提供了转发的功能,使得两台不是直连的机子也能够通信,路由表记录了相关的路由信息,指定了不同的ip地址如何处理.
linux**大支持256张路由表,一般只使用RT_TABLE_LOCAL以及RT_TABLE_MAIN这两种(默认路由也在main表中的),其他的一般都供策略路由使用
策略路由由编译选项决定(CONFIG_IP_MULTIPLE_TABLES),使得路由选择不再完全由目的ip决定,还可以考虑其他参数,如包的接收网口等,即路由规则
默认路由规则有三条,即一次到RT_TABLE_LOCAL.RT_TABLE_LOCAL,RT_TABLE_LOCAL中寻找匹配的项.



增加流程如下:在中间增加一条路由规则,指明什么情况下选择哪张路由表,然后在对应的路由表中增加路由项.
enum rt_class_t {
    RT_TABLE_UNSPEC=0,
/* User defined values */
    RT_TABLE_COMPAT=252,
    RT_TABLE_LOCAL=253,
    RT_TABLE_LOCAL=254,
    RT_TABLE_LOCAL=255,
    RT_TABLE_MAX=0xFFFFFFFF
}
默认的路由规则以及路由表:



root@:~# ip rule list
0: from all lookup local
32766: from all lookup main
32767: from all lookup default

root@:~# ip route list table local
broadcast 127.0.0.0 dev lo proto kernel scope link src 127.0.0.1
local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1
local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
broadcast 128.5.210.0 dev eth0 proto kernel scope link src 128.5.210.2
local 128.5.210.2 dev eth0 proto kernel scope host src 128.5.210.2
broadcast 128.5.210.255 dev eth0 proto kernel scope link src 128.5.210.2
broadcast 192.168.1.0 dev wlan0 proto kernel scope link src 192.168.1.107
local 192.168.1.107 dev wlan0 proto kernel scope host src 192.168.1.107
broadcast 192.168.1.255 dev wlan0 proto kernel scope link src 192.168.1.107

root@:~# ip route list table main
default via 192.168.1.1 dev wlan0 proto static
128.5.210.0/24 dev eth0 proto kernel scope link src 128.5.210.2
192.168.1.0/24 dev wlan0 proto kernel scope link src 192.168.1.107 metric 9


root@:~# ip route list table default
初始化
fib_net_init--->ip_fib_net_init----------------->fib4_rules_init-------------->fib_default_rules_init
                    nl_fib_lookup_init



ip_fib_net_init函数中分配路由表属需hash表的空间:net->ipv4.fib_table_hash = kzalloc(size, GFP_KERNEL);size_t size = sizeof(struct hlist_head) * FIB_TABLE_HASHSZ; //256
注册fib_rules_ops处理函数,在函数fib_default_rules_init中增加默认的三条路由规则

static int fib_default_rules_init(struct fib_rules_ops *ops)
{
    int err;



    err = fib_default_rule_add(ops, 0, RT_TABLE_LOCAL, 0);
    if (err < 0)
        return err;
    err = fib_default_rule_add(ops, 0x7FFE, RT_TABLE_MAIN, 0);
    if (err < 0)
        return err;
    err = fib_default_rule_add(ops, 0x7FFF, RT_TABLE_DEFAULT, 0);
    if (err < 0)
        return err;
    return 0;
}
路由规则初始化后相应的数据结构如下:

在策略路由打开的情况下,路由表的创建**函数:

struct fib_table *fib_new_table(struct net *net, u32 id)
{
    struct fib_table *tb;
    unsigned int h;


    if (id == 0)
        id = RT_TABLE_MAIN;
    tb = fib_get_table(net, id);
    if (tb)
        return tb;

    tb = fib_trie_table(id);
    if (!tb)
        return NULL;
    h = id & (FIB_TABLE_HASHSZ - 1);
    hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
    return tb;
}



新的内核代码中路由表中的路由使用trie进行组织,每个fib_table数据结构的**后都挂有一个trie的结构//t = (struct trie *) tb->tb_data; http://www.luyouqiwang.com/16486/ 
下面以插入一项路由为例说明相应的数据结构之间的关系，如果执行ifconfig  eth0.1 10.20.30.40/24，则会在MAIN的路由表中插入如下的表项:
10.20.30.0/24 dev eth0 proto kernel scope link src 10.20.30.40

插入函数如下:



int fib_table_insert(struct fib_table *tb, struct fib_config *cfg)
{
    struct trie *t = (struct trie *) tb->tb_data;
    struct fib_alias *fa, *new_fa;
    struct list_head *fa_head = NULL;
    struct fib_info *fi;
    int plen = cfg->fc_dst_len;  //掩码长度
    u8 tos = cfg->fc_tos;
    u32 key, mask;
    int err;
    struct leaf *l;

    if (plen > 32)
        return -EINVAL;



    key = ntohl(cfg->fc_dst);   //目的地址

    pr_debug("Insert table=%u x/%d\n", tb->tb_id, key, plen);


    mask = ntohl(inet_make_mask(plen));



    if (key & ~mask)
        return -EINVAL;

    key = key & mask;



    fi = fib_create_info(cfg);
    if (IS_ERR(fi)) {
        err = PTR_ERR(fi);
        goto err;
    }

    l = fib_find_node(t, key);
    fa = NULL;


    if (l) {
        fa_head = get_fa_head(l, plen);
        fa = fib_find_alias(fa_head, tos, fi->fib_priority);
    }


    /* Now fa, if non-NULL, points to the first fib alias
     * with the same keys [prefix,tos,priority], if such key already
     * exists or to the node before which we will insert new one.
     *
     * If fa is NULL, we will need to allocate a new one and
     * insert to the head of f.
     *
     * If f is NULL, no fib node matched the destination key
     * and we need to allocate a new one of those as well.
     */

    if (fa && fa->fa_tos == tos &&
     fa->fa_info->fib_priority == fi->fib_priority) {
        struct fib_alias *fa_first, *fa_match;

        err = -EEXIST;
        if (cfg->fc_nlflags & NLM_F_EXCL)
            goto out;


        /* We have 2 goals:
         * 1. Find exact match for type, scope, fib_info to avoid
         * duplicate routes
         * 2. Find next fa (or head), NLM_F_APPEND inserts before it
         */
        fa_match = NULL;
        fa_first = fa;
        fa = list_entry(fa->fa_list.prev, struct fib_alias, fa_list);
        list_for_each_entry_continue(fa, fa_head, fa_list) {
            if (fa->fa_tos != tos)
                break;
            if (fa->fa_info->fib_priority != fi->fib_priority)



                break;
            if (fa->fa_type == cfg->fc_type &&
             fa->fa_info == fi) {
                fa_match = fa;
                break;
            }
        }



        if (cfg->fc_nlflags & NLM_F_REPLACE) {
            struct fib_info *fi_drop;
            u8 state;


            fa = fa_first;
            if (fa_match) {
                if (fa == fa_match)
                    err = 0;
                goto out;
            }
            err = -EBUFS;
            new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
            if (new_fa == NULL)
                goto out;


            fi_drop = fa->fa_info;
            new_fa->fa_tos = fa->fa_tos;
            new_fa->fa_info = fi;
            new_fa->fa_type = cfg->fc_type;
            state = fa->fa_state;
            new_fa->fa_state = state & ~FA_S_ACCESSED;


            list_replace_rcu(&fa->fa_list, &new_fa->fa_list);
            alias_free_mem_rcu(fa);


            fib_release_info(fi_drop);
            if (state & FA_S_ACCESSED)
                rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
            rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen,
                tb->tb_id, &cfg->fc_nlinfo, NLM_F_REPLACE);



            goto succeeded;
        }
        /* Error if we find a perfect match which
         * uses the same scope, type, and nexthop
         * information.
         */
        if (fa_match)
            goto out;

        if (!(cfg->fc_nlflags & NLM_F_APPEND))
            fa = fa_first;
    }
    err = -EENT;
    if (!(cfg->fc_nlflags & NLM_F_CREATE))
        goto out;


    err = -EBUFS;
    new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
    if (new_fa == NULL)
        goto out;

    new_fa->fa_info = fi;
    new_fa->fa_tos = tos;
    new_fa->fa_type = cfg->fc_type;
    new_fa->fa_state = 0;
    /*
     * Insert new entry to the list.
     */



    if (!fa_head) {
        fa_head = fib_insert_node(t, key, plen);
        if (unlikely(!fa_head)) {
            err = -EMEM;
            goto out_free_new_fa;
        }
    }


    if (!plen)
        tb->tb_num_default ;

    list_add_tail_rcu(&new_fa->fa_list,
             (fa ? &fa->fa_list : fa_head));



    rt_cache_flush(cfg->fc_nlinfo.nl_net, -1);
    rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen, tb->tb_id,
         &cfg->fc_nlinfo, 0);
succeeded:
    return 0;

out_free_new_fa:
    kmem_cache_free(fn_alias_kmem, new_fa);
out:
    fib_release_info(fi);
err:
    return err;
}


相关推荐：

苏州思科认证培训   苏州思科认证培训班   苏州思科认证培训学校

三网IT

进入机构首页
苏州三网IT教育

上课地址：苏州市干将东路666号和基广场

预约试听

倒计时：
11 : 58 : 41
其他试听课程
机构全部课程

学校课程导航

找不到你想要的课程？试一下全站课程搜索

机构首页
在线客服
咨询报名
预约试听