Пример #1
0
/*FUNCTION*------------------------------------------------
* 
* Function Name: PPP_start
* Comments     :
*    
*
*END*-----------------------------------------------------*/
void PPP_start(void)
{
    uint_32           error;

    _rtcs_if_handle   ihandle;
    MQX_FILE_PTR      pfile;
    _iopcb_handle     pio;
    _ppp_handle       phandle;
    IPCP_DATA_STRUCT  ipcp_data;

    _PPP_PAP_RSECRETS = rsecrets;    /* Require authentication, allow PAP */
    _PPP_PAP_LSECRET = &lsecret;     /* Allow peer to request PAP */
    _PPP_CHAP_LNAME = localname;     /* Needed by CHAP */
    _PPP_CHAP_RSECRETS = rsecrets;   /* Require authentication, allow CHAP */
    _PPP_CHAP_LSECRETS = lsecrets;   /* Allow peer to request CHAP */

    /* Install a route for a default gateway */
    RTCS_gate_add(GATE_ADDR, INADDR_ANY, INADDR_ANY);

    pfile = fopen(PPP_DEVICE, NULL);
#ifdef PPP_DEVICE_DUN
    _io_dun_install("dun:");
    pfile = fopen("dun:", (char_ptr)pfile);
#endif
 
    pio = _iopcb_ppphdlc_init(pfile);
    _PPP_ACCM = 0;
    error = PPP_initialize(pio, &phandle);
    if (error) {
       printf("\nPPP initialize: %lx", error);
       _task_block();
    } /* Endif */

    _iopcb_open(pio, PPP_lowerup, PPP_lowerdown, phandle);
    error = RTCS_if_add(phandle, RTCS_IF_PPP, &ihandle);
    if (error) {
       printf("\nIF add failed, error = %lx", error);
       _task_block();
    } /* Endif */
    _lwsem_create(&ppp_sem, 0);
    _mem_zero(&ipcp_data, sizeof(ipcp_data));
    ipcp_data.IP_UP              = PPP_linkup;
    ipcp_data.IP_DOWN            = NULL;
    ipcp_data.IP_PARAM           = &ppp_sem;
    ipcp_data.ACCEPT_LOCAL_ADDR  = FALSE;
    ipcp_data.ACCEPT_REMOTE_ADDR = FALSE;
    ipcp_data.LOCAL_ADDR         = PPP_LOCADDR;
    ipcp_data.REMOTE_ADDR        = PPP_PEERADDR;
    ipcp_data.DEFAULT_NETMASK    = TRUE;
    ipcp_data.DEFAULT_ROUTE      = TRUE;
    error = RTCS_if_bind_IPCP(ihandle, &ipcp_data);
    if (error) {
       printf("\nIF bind failed, error = %lx", error);
       _task_block();
    } /* Endif */
    printf("\nPlease initiate PPP connection.  Waiting...");
    _lwsem_wait(&ppp_sem);
    printf("\nPPP device %s bound to %d.%d.%d.%d", PPP_DEVICE, IPBYTES(ipcp_data.LOCAL_ADDR));
}
Пример #2
0
_ppp_handle PPP_init
   (
        PPP_PARAM_STRUCT*     params
   )
{ /* Body */

#if RTCSCFG_ENABLE_IP4 
    PPP_CFG_PTR          ppp_ptr;
    uint32_t             error;
    IPCP_DATA_STRUCT     ipcp_data;
    int stage = 0;

    /* Allocate the state structure */
    ppp_ptr = _mem_alloc_zero(sizeof(PPP_CFG));
    
    if (!ppp_ptr)
    {
        return(NULL);
    }
    ppp_ptr->DEVICE_NAME = _mem_alloc_zero(strlen(params->device)+1);
    if (ppp_ptr->DEVICE_NAME == NULL)
    {
        _mem_free(ppp_ptr);
        return(NULL);
    }
    strcpy(ppp_ptr->DEVICE_NAME, params->device);
    /* Stage 0 - Open low level device */
    ppp_ptr->IOPCB_DEVICE = fopen(params->device, NULL);
    if (ppp_ptr->IOPCB_DEVICE == NULL)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 1 - Initialize HDLC and lwsem */
    ppp_ptr->DEVICE = _iopcb_ppphdlc_init(ppp_ptr->IOPCB_DEVICE);
    if (ppp_ptr->DEVICE == NULL)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }

    ppp_ptr->RECV_OPTIONS = &PPP_DEFAULT_OPTIONS;
    ppp_ptr->SEND_OPTIONS = &PPP_DEFAULT_OPTIONS;

    if (_lwsem_create(&ppp_ptr->MUTEX, 1))
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 2 - Initialize LCP */
    error = LCP_init(ppp_ptr);
    if (error)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 3 - Initialize and open CCP */
    /*
    error = CCP_init(ppp_ptr);
    if (error)
    {
        PPP_init_fail(ppp_ptr, stage);
        return error;
    }
    CCP_open(ppp_ptr);
    */
    stage++;

    /* Stage 4 - Create a pool of message buffers */
    ppp_ptr->MSG_POOL = RTCS_msgpool_create(sizeof(PPP_MESSAGE), PPP_MESSAGE_INITCOUNT, PPP_MESSAGE_GROWTH, PPP_MESSAGE_LIMIT);
    if (ppp_ptr->MSG_POOL == MSGPOOL_NULL_POOL_ID)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 5 - Create the Tx Task */
    error = RTCS_task_create("PPP tx", _PPPTASK_priority, _PPPTASK_stacksize + 1000, PPP_tx_task, ppp_ptr);
    if (error)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    } 
    stage++;

    /* Stage 6 - Create the Rx Task */
    ppp_ptr->STOP_RX = FALSE; 

    error = RTCS_task_create("PPP rx", _PPPTASK_priority, _PPPTASK_stacksize + 1000, PPP_rx_task, ppp_ptr);
    if (error)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 7 - Open HDLC layer */
    error = _iopcb_open(ppp_ptr->DEVICE, PPP_lowerup, PPP_lowerdown, ppp_ptr);
    if (error != PPPHDLC_OK)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    ppp_ptr->VALID = PPP_VALID;
    stage++;

    /* Stage 8 - Add PPP interface to RTCS */
    error = RTCS_if_add(ppp_ptr, RTCS_IF_PPP, &ppp_ptr->IF_HANDLE);
    if (error != RTCS_OK)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    stage++;

    /* Stage 9 - Bind IP address to PPP interface */
    _mem_zero(&ipcp_data, sizeof(ipcp_data));
    ipcp_data.IP_UP              = params->up;
    ipcp_data.IP_DOWN            = params->down;
    ipcp_data.IP_PARAM           = params->callback_param;

    if(params->listen_flag == 0)
    {
        ipcp_data.ACCEPT_LOCAL_ADDR  = TRUE;
        ipcp_data.ACCEPT_REMOTE_ADDR = TRUE;
    }
    else
    {
        ipcp_data.ACCEPT_LOCAL_ADDR  = FALSE;
        ipcp_data.ACCEPT_REMOTE_ADDR = FALSE;
    }
    ipcp_data.LOCAL_ADDR         = params->local_addr;
    ipcp_data.REMOTE_ADDR        = params->remote_addr;
    ipcp_data.DEFAULT_NETMASK    = TRUE;
    ipcp_data.DEFAULT_ROUTE      = TRUE;

    error = RTCS_if_bind_IPCP(ppp_ptr->IF_HANDLE, &ipcp_data);
    if (error != RTCS_OK)
    {
        PPP_init_fail(ppp_ptr, stage);
        return(NULL);
    }
    params->if_handle = ppp_ptr->IF_HANDLE;
    stage++;

    /* Stage 10 - Init complete, return handle */
    return(ppp_ptr);

#else

    return(NULL);    

#endif /* RTCSCFG_ENABLE_IP4 */

} /* Endbody */
Пример #3
0
/*FUNCTION*------------------------------------------------
*
* Function Name: shell_ppp_start()
* Comments     :
*   This function start PPP communication and try to establish PPP connection.
*END*-----------------------------------------------------*/
void shell_ppp_start(SHELL_PPP_LINK_PTR ppp_current)
{
     uint_32           error;
     _ip_address       local_address;
     _ip_address       peer_address=0;
     IPCP_DATA_STRUCT  ipcp_data;

    /* This is configuration for PAP. */
     char* localname     = ppp_current->LOCAL_NAME;
     char* localsecret   = ppp_current->LOCAL_PASSWORD;
     PPP_SECRET lsecret;
    if(default_ppp.SERVER_FLAG==0)
    {   /* Setup  PAP for client mode.*/
         lsecret.PPP_ID_LENGTH = strlen(localname);
         lsecret.PPP_PW_LENGTH = strlen(localsecret);
         lsecret.PPP_ID_PTR    = localname;
         lsecret.PPP_PW_PTR    = localsecret;
        _PPP_PAP_LSECRET   = &lsecret; /* lsecrets  */
        _PPP_PAP_RSECRETS  =  NULL;    /* rsecrets  */
        _PPP_CHAP_LNAME    =  NULL;    /* localname */
        _PPP_CHAP_LSECRETS =  NULL;    /* lsecrets  */
        _PPP_CHAP_RSECRETS =  NULL;    /* rsecrets  */
    }
    else if(default_ppp.SERVER_FLAG==1)
    {   /* Setup  PAP for server mode.*/
        _PPP_PAP_LSECRET   =  NULL;                  /* lsecrets  */
        _PPP_PAP_RSECRETS  =  ppp_current->rsecrets; /* rsecrets  */
        _PPP_CHAP_LNAME    =  NULL;                  /* localname */
        _PPP_CHAP_LSECRETS =  NULL;                  /* lsecrets  */
        _PPP_CHAP_RSECRETS =  NULL;                  /* rsecrets  */
    }
    else
    {
         ppp_current->PPP_HANDLE = NULL;
         return;
    }

   /* Install a route for a default gateway */
    RTCS_gate_add(ppp_current->PPP_GATE_ADDR, INADDR_ANY, INADDR_ANY);

    ppp_current->PPP_IO_DRIVER_HANDLE = _iopcb_ppphdlc_init(ppp_current->PPP_DEV_HANDLE);
    _PPP_ACCM = 0;
    error = PPP_initialize(ppp_current->PPP_IO_DRIVER_HANDLE, &ppp_current->PPP_HANDLE);
    if (error)
    {
       printf("\n PPP initialize: %lx", error);
       _task_block();
    }
    _iopcb_open(ppp_current->PPP_IO_DRIVER_HANDLE, PPP_lowerup, PPP_lowerdown,ppp_current->PPP_HANDLE);
    error = RTCS_if_add(ppp_current->PPP_HANDLE, RTCS_IF_PPP, &ppp_current->PPP_IF_HANDLE);
    if (error)
    {
       printf("\n IF add failed, error = %lx", error);
       _task_block();
    }
    _lwsem_create(&ppp_current->PPP_SEM, 0);
    _mem_zero(&ipcp_data, sizeof(ipcp_data));
    ipcp_data.IP_UP              = PPP_linkup;
    ipcp_data.IP_DOWN            = PPP_linkdown;
    ipcp_data.IP_PARAM           = &ppp_current->PPP_SEM;

    if(default_ppp.SERVER_FLAG==0)
    {
        ipcp_data.ACCEPT_LOCAL_ADDR  = TRUE;
        ipcp_data.ACCEPT_REMOTE_ADDR = TRUE;
    }
    else
    {
        ipcp_data.ACCEPT_LOCAL_ADDR  = FALSE;
        ipcp_data.ACCEPT_REMOTE_ADDR = FALSE;
    }
    ipcp_data.LOCAL_ADDR         = ppp_current->PPP_LOCAL_ADDRESS;
    ipcp_data.REMOTE_ADDR        = ppp_current->PPP_REMOTE_ADDRESS;
    ipcp_data.DEFAULT_NETMASK    = TRUE;
    ipcp_data.DEFAULT_ROUTE      = TRUE;

    error = RTCS_if_bind_IPCP(ppp_current->PPP_IF_HANDLE, &ipcp_data);

    if (error)
    {
       printf("\n IF bind failed, error = %lx", error);
       _task_block();
    }

    /*In case "client" we need wait for connection to server*/
    if(default_ppp.SERVER_FLAG==0)
    {
        printf("\n Please wait initiate PPP connection.  Waiting...\n");
       /*Handshake with RAS server */
       /* 10 attempts to connect */
        error = 0;
        while (error < 10)
        {
            if (PPP_link == FALSE)
            {
                _time_delay(1000);
            }
            else
            {
                printf("\n PPP_link = %d, time = %d\n",PPP_link,error);
                break;
            }
            error ++;
        }

        if (PPP_link == TRUE)
        {
            local_address = IPCP_get_local_addr(ppp_current->PPP_IF_HANDLE);
            peer_address = IPCP_get_peer_addr(ppp_current->PPP_IF_HANDLE);
            printf("\n PPP device on %s is bound on.\n", ppp_current->PPP_CONNECTION_DEVICE );
            printf(" PPP local  address is : %d.%d.%d.%d\n", IPBYTES(local_address));
            printf(" PPP remote address is : %d.%d.%d.%d\n", IPBYTES(peer_address));
            printf(" Now PPP connection is established on %d.%d.%d.%d\n", IPBYTES(peer_address));
        }
        else
        {
            if(ppp_current->PPP_HANDLE)
            {
               /* clean up all PPP structure */
                error = PPP_shutdown(ppp_current->PPP_HANDLE);
            }
            ppp_current->PPP_HANDLE = NULL;
           /* We shoul remove route to clear part block. */
            RTCS_gate_remove(ppp_current->PPP_GATE_ADDR, INADDR_ANY, INADDR_ANY);
        }

    }
    else
    {
       /* In case of "server" we do not need wait at all. */
        printf("\n PPP server ready and waiting for connection.\n");
    }
}