rrtask.c

用于嵌入式系统的TCP/IP协议栈及若干服务

														  rrmsg->gw,
														  cid, rrmsg->cost);
                    break;
                case DEL_LOCAL_ROUTE:
                    trace0(fr_trace, "DEL_LOCAL_ROUTE\n");
                    rrmsg = (fns_route_msg *)rlp->inmsg;
                    rlp->route_status =
                    ip_del_lroute_circuit( rlp->route_ndp, &rrmsg->ipna);
                    break;
                case DEL_STATIC_ROUTE:
                    trace0(fr_trace, "DEL_STATIC_ROUTE\n");
                    rrmsg = (fns_route_msg *)rlp->inmsg;
                    rlp->route_status = ipDelStaticRoute(&rrmsg->ipna);
                    break;
                case GET_ROUTE_TABLE:
                    trace0(fr_trace,"GET_ROUTE_TABLE\n");
                    rlp->route_status = 
                        ipGetRoutingTable( rlp->rmsg );
                    break;
                case ADD_ROUTE_LEAK:
                    trace0(fr_trace, "ADD_ROUTE_LEAK\n");
                    rlmsg = (fns_rleak_msg *)rlp->inmsg;
                    rlp->route_status = ipRedistAddDel( rlmsg->dest_prot,
                                                        rlmsg->src_prot,
                                                        1, rlmsg->parm, &rlp->route_status );
                    break;
                case DEL_ROUTE_LEAK:
                    trace0(fr_trace, "DEL_ROUTE_LEAK\n");
                    rlmsg = (fns_rleak_msg *)rlp->inmsg;
                    rlp->route_status = ipRedistAddDel( rlmsg->dest_prot,
                                                        rlmsg->src_prot,
                                                        0, rlmsg->parm, &rlp->route_status );
                    break;
#ifdef RIP_PROTOCOL
                case RIP_MSG_ENABLE_RIP:   /* Administratively enable RIP (global to all interfaces) */
                    trace0(fr_trace, "ADD_LOCAL_ROUTE\n");
                    rlp->route_status = RipEnable();
                    break;
                case RIP_MSG_DISABLE_RIP:  /* Administratively disable RIP "" */
                    trace0(fr_trace, "ADD_LOCAL_ROUTE\n");
                    rlp->route_status = RipDisable(0);
                    break;
                case RIP_MSG_CONFIG_INTERFACE: /* Configure a circuit on an interface */
                    trace0(fr_trace, "RIP_MSG_CONFIG_INTERFACE\n");
                    cid = ndp_2_cid(rlp->route_ndp);
                    rlp->route_status =
                        rip_do_configure_interface( cid , (rip_if_config *)rlp->inmsg );
                    break;
                case RIP_MSG_GET_INTERFACE_INFO: /* Configure a circuit on an interface */
                    trace0(fr_trace, "RIP_MSG_GET_INTERFACE_INFO\n");
                    cid = ndp_2_cid(rlp->route_ndp);
                    rlp->route_status =
                        rip_do_get_interface_info(cid, (rip_if_config *)rlp->rmsg);
                    break;
                case RIP_MSG_GET_ADMIN_STATE: /* Configure a circuit on an interface */
                    trace0(fr_trace, "RIP_MSG_GET_ADMIN_STATE\n");
                    rlp->route_status =
                        rip_do_get_admin_state((u32 *)&rlp->rmsg);
                    break;
#endif
#ifdef OSPF_PROTOCOL
                case OSPF_GLOBAL_CFG:
                    trace0(fr_trace, "OSPF_GLOBAL_CFG\n");
                    rlp->route_status = 
                        _do_ospf_global_config(rlp->inmsg );
                    break;
                case OSPF_AREA_CFG:
                    trace0(fr_trace, "OSPF_AREA_CFG\n");
                    rlp->route_status = 
                        _do_ospf_area_config(rlp->inmsg );
                    break;
                case OSPF_RANGE_CFG:
                    trace0(fr_trace, "OSPF_RANGE_CFG\n");
                    rlp->route_status = 
                        _do_ospf_range_config(rlp->inmsg );
                    break;
                case OSPF_IF_CFG:
                    trace0(fr_trace, "OSPF_IF_CFG\n");
                    rlp->route_status = 
                        _do_ospf_if_config( rlp->route_ndp, (char *)0, rlp->inmsg );
                    break;
                case OSPF_VLINK_CFG:
                    trace0(fr_trace, "OSPF_VLINK_CFG\n");
                    /* Virtual link passes the name of the vlink rather than
                       an ndp pointer.
                    */
                    rlp->route_status = 
                        _do_ospf_vlink_config( (char *)rlp->route_ndp, rlp->inmsg );
                    break;
                case OSPF_GET_NEIGHBORS:
                    rlp->route_status =
                        _do_ospf_retr_neigh_table((ospf_neigh_table_ptr)rlp->rmsg);
                    break;
                case OSPF_GET_DATABASE:  
                    rlp->route_status =
                        _do_ospf_retr_lsdb((ospf_lsdb_ptr)rlp->rmsg);
                    break;
                case OSPF_GET_AREAS:
                    rlp->route_status =
                        _do_ospf_retr_area_table((ospf_area_table_ptr)rlp->rmsg);
                   break;
                case OSPF_GET_INTERFACES:
                    rlp->route_status =
                        _do_ospf_retr_if_table((ospf_if_entry_ptr)rlp->rmsg);
                    break;


#endif /* OSPF_PROTOCOL */
                default:
                    break;
                }
                if( rlp->route_msgtype & R_MSG_IN_USE ) {
                    router_msgs -= 1;
                    rlp->route_msgtype &= ~R_MSG_MASK;
                    os_wakeup((char *)&rlp->route_status);
                }
            }

            critical;
                if (router_msgs == 0)
                  router_events &= ~R_ROUTE;

                normal;
        }

        if (router_events & R_TIC)
        {
            router_events &= ~R_TIC;
#ifdef OSPF_PROTOCOL
            ospfTic();
#endif
#ifdef RIP_PROTOCOL
            RipTic();
#endif
            if (--RtrDisc_clock == 0)
            {
              for (ndpp = ndp_tbl; ((ndp = *ndpp) != (netdev *)0); ndpp++)
              {
                if (ndp->nd_flags & F_N_IPADDRESS_SET)
                    rrIcmpTxRtrDiscAdv(ndp);
              }
              RtrDisc_clock = ICMP_RDISC_ADV_INT;
            }
        }

        if ( (router_events & R_INCOMING)
        /* just process one mp at a time in this loop to
         * give the RIP and OSPF timer fare share of the CPU
         */
            && ( (mp = (m *)gq_head(&router_r_gq, &err , false)) != (m *)0 ) )
        {
            /* snethost in network byte order */
            snethost = mp->m_src.a_ipa.ip_nethost;
#ifdef RIP_PROTOCOL
            if ( mp->m_type == IP_UDP ) { /* RIP uses UDP.  OSPF doesn't */
                /* From UDP mp->m_hp points to ULP data (i.e RIP) */
                count = m_dsize(mp);
                /* host byte order */
                sport = ntohs(mp->m_src.a_ipa.ip_port);
                cid = ndp_2_cid(mp->m_ndp);
                riprx((void *)mp->m_hp, count, cid, snethost, sport);
            }
#endif
#if defined(RIP_PROTOCOL) && defined(OSPF_PROTOCOL)
            else 
#endif
#ifdef OSPF_PROTOCOL
            if ( mp->m_type == IP_OSPF)
            {
           /* From IP mp->m_hp points to IP header and mp->m_cp points
            * to ULP data (i.e OSPF)
            */
                count = mp->m_tp - mp->m_cp;
                dnethost = mp->m_dest.a_ipa.ip_nethost;
                cid = ndp_2_cid(mp->m_ndp);
                ospf_receive((void *)mp->m_cp, count, (void *)cid , snethost, dnethost);
            }
#endif
            mgq_out(mp); /* remove from the queue */
            critical;
            /* If queue empty remove R_INCOMING flag */
            if (gq_empty(&router_r_gq))
                router_events &= ~R_INCOMING;
            normal;
            /* Free the message which was dup'ed in router_task_rx */
            mp->m_dispfn = smnil;
            smkill(mp);
        }
    }
    /* NOTREACHED */
    os_idle();
}

#ifdef USE_ROUTER_STOP
int
router_stop (void)
{
    use_critical;

    trace0(fr_trace, "router_stop\n");
    critical;
    if (router_enabled) {
        t_stop(&router_tcb);
        stop_router = true; /* tell the router we are waiting */
        router_enabled = false; /* tell the router to stop */

        while (router_state == R_RUN)
        /* wait for the router to finish */
            os_sleep(&router_state);

        stop_router = false;
        normal;
        return true;
    }
    else {
        stop_router = false;
        normal;
        return false;
    }
}
#endif /* USE_ROUTER_STOP */

/******************************* End Router Task *****************************************/


/******************************************************************************
 *
 * router_task_init
 *
 */
export  int router_task_init (void)
{
    trace0(fr_trace, "router_task_init\n");

    router_enabled = false;
    router_msgs = 0;
    router_state = R_WAIT;
    router_events = (char)0;
    OS_MEMSET((char *)&route_list[0], 0, (unsigned long)sizeof(route_list));

#ifdef USE_ROUTER_STOP
    stop_router = false;
#endif

    gq_init(&router_r_gq);
    q_init(&router_r_gq.gq_q, F_Q_HEADER);
    gq_max_set(&router_r_gq, (int)ROUTER_RQ_MAX);


    /* Never fails at present */
    return 0;
}

/***************************************************************************
 *
 * router_start_task
 *
 */
void router_start_task(void)
{
    router_enabled = true;
#ifdef USE_ROUTER_STOP
    stop_router = false;
#endif
    os_wakeup(&router_events); /* in case some router_events occurred */

}

/***************************************************************************
 *
 * router_wakeup_task
 *
 */
void router_wakeup_task(void)
{
    router_events |= R_TIC;
    os_wakeup(&router_events);
}




#else

/* Just to please compilers which don't like empty translation units */
void rrtask_dummy(void)
{

    os_printf("rrtask_dummy should never be called\n");
}

#endif