/*FUNCTION*------------------------------------------------
*
* Function Name: shell_ppp_stop
* Comments : Shell command "ppp stop" is calling this function to stop PPP connection.
*
*END*-----------------------------------------------------*/
int_32 shell_ppp_stop(SHELL_PPP_LINK_PTR local_ppp)
{
uint_32 error;
/* Check if PPP is alive. */
if(!local_ppp->PPP_HANDLE)
{
printf("Can not stop PPP.It is not started\n");
}
/* Cleanup PPP connection. */
/* Unbind interface. */
error = RTCS_if_unbind(local_ppp->PPP_IF_HANDLE, IPCP_get_local_addr(local_ppp->PPP_IF_HANDLE));
if(default_ppp.PPP_HANDLE)
{
/* Send connection terminate request to remote server and close PPP connection. */
error = PPP_close(local_ppp->PPP_HANDLE);
/* Clean up all PPP structure. */
error = PPP_shutdown(local_ppp->PPP_HANDLE);
local_ppp->PPP_HANDLE =NULL;
}
/* Destroing the semafor. */
error = _lwsem_destroy(&local_ppp->PPP_SEM);
if(local_ppp->PPP_IF_HANDLE)
{
/* Unregister PPP interface. */
error = RTCS_if_remove(local_ppp->PPP_IF_HANDLE);
local_ppp->PPP_IF_HANDLE=0;
}
if(local_ppp->PPP_IO_DRIVER_HANDLE)
{
/* Closing PPP driver. */
error = _iopcb_close(local_ppp->PPP_IO_DRIVER_HANDLE);
}
if(local_ppp->PPP_DEV_HANDLE)
{
/* Close PPP driver. */
error = fclose(default_ppp.PPP_DEV_HANDLE);
}
if(local_ppp->PPP_CON_DEV_HANDLE)
{
/* Close Close PPP_DEVICE. */
error = fclose(default_ppp.PPP_CON_DEV_HANDLE);
}
local_ppp->PPP_HANDLE = NULL;
/* We need remove route. */
RTCS_gate_remove(local_ppp->PPP_GATE_ADDR, INADDR_ANY, INADDR_ANY);
if(error)
{
printf("\nSome error happend during closing PPP connection.\n");
return RTCS_ERROR;
}
else
{
printf("PPP connection closed\n");
return RTCS_OK;
}
}
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : PPP_pause
* Returned Value : RTCS_OK
* Comments :
* Pauses PPP FSM and releases HDLC layer.
*
*END*-----------------------------------------------------------------*/
uint32_t PPP_pause(_ppp_handle handle)
{
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr = handle;
RTCS_task_destroy(ppp_ptr->RX_TASKID);
/*
** Close HDLC layer, also signalize that lower layer is down to PPP
** state machine
*/
_iopcb_close(ppp_ptr->DEVICE);
/* Release low-level (typycally ittyX) device */
fflush(ppp_ptr->IOPCB_DEVICE);
fclose(ppp_ptr->IOPCB_DEVICE);
ppp_ptr->IOPCB_DEVICE = NULL;
return(RTCS_OK);
#else
return RTCSERR_IP_IS_DISABLED;
#endif
}
uint32_t PPP_release
(
_ppp_handle handle
/* [IN] - the PPP state structure */
)
{ /* Body */
#if RTCSCFG_ENABLE_IP4
PPP_CFG_PTR ppp_ptr = handle;
_rtcs_sem sem;
uint32_t error = RTCS_OK;
/* wait time in 0.1 Sec */
uint32_t wait_time = 50;
/* delay time in mS */
uint32_t delay_time = 100;
if (ppp_ptr == NULL)
{
return(RTCS_OK);
}
error = RTCS_if_unbind(ppp_ptr->IF_HANDLE, IPCP_get_local_addr(ppp_ptr->IF_HANDLE));
if (error != RTCS_OK)
{
return(error);
}
ppp_ptr->STOP_RX = TRUE;
/* Waiting before Rx task will be closed or kill it. */
while(ppp_ptr->STOP_RX)
{
_time_delay(delay_time);
wait_time--;
if(!wait_time)
{
error = RTCSERR_TIMEOUT;
RTCS_task_destroy(ppp_ptr->RX_TASKID);
break;
}
}
error = PPP_close(ppp_ptr);
if (error != PPP_OK)
{
return(error);
}
/* Kill Tx task */
RTCS_sem_init(&sem);
PPP_send_shutdown(ppp_ptr, &sem);
RTCS_sem_wait(&sem);
RTCS_sem_destroy(&sem);
error = _iopcb_close(ppp_ptr->DEVICE);
if (error != RTCS_OK)
{
return(error);
}
error = _iopcb_ppphdlc_release(ppp_ptr->DEVICE);
if (error != RTCS_OK)
{
return(error);
}
ppp_ptr->DEVICE = NULL;
error = RTCS_msgpool_destroy(ppp_ptr->MSG_POOL);
if (error != MQX_OK)
{
return(error);
}
/*
error = CCP_destroy(ppp_ptr);
if (error != PPP_OK)
{
return(error);
}
*/
error = LCP_destroy(ppp_ptr);
if (error != PPP_OK)
{
return(error);
}
PPP_mutex_destroy(&ppp_ptr->MUTEX);
if (ppp_ptr->IOPCB_DEVICE)
{
fflush(ppp_ptr->IOPCB_DEVICE);
error = fclose(ppp_ptr->IOPCB_DEVICE);
if (error != RTCS_OK)
{
return(error);
}
}
error = RTCS_if_remove(ppp_ptr->IF_HANDLE);
if (error != RTCS_OK)
{
return(error);
}
PPP_memfree(handle);
return(error);
#else
return RTCSERR_IP_IS_DISABLED;
#endif /* RTCSCFG_ENABLE_IP4 */
} /* Endbody */
/*FUNCTION*-------------------------------------------------------------
*
* Function Name : PPP_init_fail
* Returned Value : none
* Comments :
* Do cleanup when initialization fails.
*
*END*-----------------------------------------------------------------*/
void PPP_init_fail(PPP_CFG_PTR ppp_ptr, int stage)
{
if (stage > 0)
{
fclose(ppp_ptr->IOPCB_DEVICE);
_mem_free(ppp_ptr->DEVICE_NAME);
ppp_ptr->DEVICE_NAME = NULL;
}
if (stage > 1)
{
_lwsem_destroy(&ppp_ptr->MUTEX);
}
if (stage > 2)
{
LCP_destroy(ppp_ptr);
}
if (stage > 3)
{
// CCP_close(ppp_ptr);
// CCP_destroy(ppp_ptr);
}
if (stage > 5)
{
LWSEM_STRUCT sem;
RTCS_sem_init(&sem);
PPP_send_shutdown(ppp_ptr, &sem);
RTCS_sem_wait(&sem);
RTCS_sem_destroy(&sem);
}
/* Message pool must be destroyed after we send shutdown message to TX task */
if (stage > 4)
{
RTCS_msgpool_destroy(ppp_ptr->MSG_POOL);
}
if (stage > 6)
{
uint32_t wait_time = 50;
uint32_t delay_time = 100;
ppp_ptr->STOP_RX = TRUE;
while(ppp_ptr->STOP_RX)
{
_time_delay(delay_time);
wait_time--;
if(!wait_time)
{
RTCS_task_destroy(ppp_ptr->RX_TASKID);
break;
}
}
}
if (stage > 7)
{
_iopcb_close(ppp_ptr->DEVICE);
}
if (stage > 8)
{
RTCS_if_unbind(ppp_ptr->IF_HANDLE, IPCP_get_local_addr(ppp_ptr->IF_HANDLE));
RTCS_if_remove(ppp_ptr->IF_HANDLE);
}
_mem_free(ppp_ptr);
}
/*FUNCTION*------------------------------------------------
*
* Function Name: Shell_ppp
* Comments : Shell command "ppp" is starting or stopping PPP connection.
*
*END*-----------------------------------------------------*/
int_32 Shell_ppp(int_32 argc, char_ptr argv[] )
{
uint_32 error;
uint_32 i=1;
boolean print_usage, shorthelp = FALSE;
default_ppp.LOCAL_NAME = NULL;
default_ppp.LOCAL_PASSWORD = NULL;
/* Check for help. */
print_usage = Shell_check_help_request(argc, argv, &shorthelp );
if (!print_usage)
{
if (argc >= 2)
{ /* If we have more args, we need parce them. */
while(i<argc)
{
switch (i)
{
case (1):
/* If "stop" start shell_ppp_stop. */
if( strcmp(argv[i],"stop")==0)
{
return(shell_ppp_stop(&default_ppp));
}
else if(strcmp(argv[i],"client")==0)
{
default_ppp.SERVER_FLAG=0;
}
else if(strcmp(argv[i],"server")==0)
{
default_ppp.SERVER_FLAG=1;
/* In case of "server" we need have min 7 arg : ppp server ittyX: rlogin rpassword boardip clientip */
if(argc <=6)
{
print_usage = TRUE;
}
}
else
{
print_usage = TRUE;
}
break;
case (2):
if( strstr(argv[i],"itty") !=0)
{
default_ppp.PPP_CONNECTION_DEVICE = argv[i];
}
else
{
printf("Incorrect ittyX: device name.\n");
print_usage = TRUE;
}
break;
case (3):
if(default_ppp.SERVER_FLAG==0)
{
default_ppp.LOCAL_NAME = argv[i];
}
else
{
default_ppp.REMOTE_NAME = argv[i];
}
break;
case (4):
if(default_ppp.SERVER_FLAG==0)
{
default_ppp.LOCAL_PASSWORD = argv[i];
}
else
{
default_ppp.REMOTE_PASSWORD = argv[i];
}
break;
case (5):
if(default_ppp.SERVER_FLAG==1)
{ /* It is valid only for server mode.*/
if( inet_pton(AF_INET, argv[i],&default_ppp.PPP_LOCAL_ADDRESS,sizeof(default_ppp.PPP_LOCAL_ADDRESS)) == (uint_32)RTCS_ERROR)
{
print_usage = TRUE;
}
}
else
{
print_usage = TRUE;
}
break;
case (6):
if(default_ppp.SERVER_FLAG==1)
{ /* It is valid only for server mode.*/
if( inet_pton(AF_INET, argv[i],&default_ppp.PPP_REMOTE_ADDRESS,sizeof(default_ppp.PPP_REMOTE_ADDRESS)) ==(uint_32)RTCS_ERROR)
{
print_usage = TRUE;
}
}
else
{
print_usage = TRUE;
}
break;
default:
error = 0;
break;
}
i++;
}
}
else
{
print_usage = TRUE;
}
}
if (print_usage)
{
if (shorthelp)
{
printf(" %s - Start PPP connection. \n", argv[0]);
return RTCS_OK;
}
else
{
printf(" Usage: %s\n", argv[0]);
printf(" [param] [device name] [login] [password] [localIPaddress ] [remoteIPaddress]\n");
printf(" [param] - is \"server\", \"client\" \"stop\"\n");
printf(" [device name] - is system name of interrupting device,\n");
printf(" suitable for your board, like ittyX: \n");
printf(" [login] and\n");
printf(" [password] - is \"login\" and \"password\" for PPP PAP.\n");
printf(" For \"server\" login and pass should be defined. \n");
printf(" For \"server\" and \"client\" the device name is requered.\n");
printf(" [localIPaddress] - is IP addres of your board(server mode).\n");
printf(" [remoteIPaddress] - is IP addres for client of your board(server mode).\n");
printf("\n Examples:\n");
printf(" To start PPP client using \"ittyd:\" you need type:\n");
printf(" shell> ppp client ittyd: \n");
printf(" or using PPP PAP client:\n");
printf(" shell> ppp client ittyd: yourlogin yourpassword \n");
printf("\n To start PPP PAP server using \"ittyd:\":\n");
printf(" shell> ppp server ittyd: yrlog yrpass brd_ip_addr cl_ip_addr\n");
printf(" shell> ppp server ittyd: guest anon 192.168.0.1 192.168.0.217\n");
printf("\n To stop PPP connection you need type \"ppp stop\":\n");
printf(" shell> ppp stop\n\n");
return RTCS_OK;
}
}
/* Check if PPP already started. */
if(default_ppp.PPP_HANDLE)
{
printf("\n PPP already started. Stop it first.\n");
return RTCS_OK;
}
/* Start connection: */
/* Open serial device. */
default_ppp.PPP_CON_DEV_HANDLE = fopen(default_ppp.PPP_CONNECTION_DEVICE, NULL);
/* Open suitable ppp device. */
if(default_ppp.SERVER_FLAG==0)
{
/* Open PPP like client. */
default_ppp.PPP_DEV_HANDLE = fopen("dcn:", (char_ptr)default_ppp.PPP_CON_DEV_HANDLE);
/* Checking, does it open ? */
if(default_ppp.PPP_DEV_HANDLE == NULL)
{
if(default_ppp.PPP_CON_DEV_HANDLE)
{
/* Close PPP_DEVICE. */
fclose(default_ppp.PPP_CON_DEV_HANDLE);
}
printf("\n ERROR: Can not open \"dcn\" PPP driver.\n");
return RTCS_ERROR;
}
}
else
{
/* Open PPP like server. */
default_ppp.PPP_DEV_HANDLE = fopen("dun:", (char_ptr)default_ppp.PPP_CON_DEV_HANDLE);
/* Checking, does it open ? */
if(default_ppp.PPP_DEV_HANDLE == NULL)
{
/* Checking, was driver installed or not. */
if(default_ppp.PPP_CON_DEV_HANDLE)
{
/* Close Close PPP_DEVICE. */
fclose(default_ppp.PPP_CON_DEV_HANDLE);
}
printf("\n ERROR: Can not open \"dun\" PPP driver.\n");
return RTCS_ERROR;
}
}
if(default_ppp.SERVER_FLAG==0)
{
/* Send invitation string to Windows PPP server. */
_io_fputs("CLIENTCLIENT", default_ppp.PPP_DEV_HANDLE);
fflush(default_ppp.PPP_DEV_HANDLE);
/* Start connection procedure. */
default_ppp.PPP_GATE_ADDR = IPADDR(192,168,0,1);
}
else
{
default_ppp.PPP_GATE_ADDR = default_ppp.PPP_LOCAL_ADDRESS;
/* Fill rsecrets[] array here. */
default_ppp.rsecrets[0].PPP_ID_LENGTH = strlen(default_ppp.REMOTE_NAME);
default_ppp.rsecrets[0].PPP_PW_LENGTH = strlen(default_ppp.REMOTE_PASSWORD);
default_ppp.rsecrets[0].PPP_ID_PTR = default_ppp.REMOTE_NAME;
default_ppp.rsecrets[0].PPP_PW_PTR = default_ppp.REMOTE_PASSWORD;
default_ppp.rsecrets[1].PPP_ID_LENGTH = 0;
default_ppp.rsecrets[1].PPP_PW_LENGTH = 0;
default_ppp.rsecrets[1].PPP_ID_PTR = NULL;
default_ppp.rsecrets[1].PPP_PW_PTR = NULL;
}
shell_ppp_start(&default_ppp);
/* shell_ppp_start() must get PPP_HANDLE */
if(default_ppp.PPP_HANDLE)
{
return RTCS_OK;
}
else
{ /* Remove all created elements. */
printf("\n Error: The connection attemp failed because the modem (or other connecting device) on the remote computer is out of order \n");
/* Destroy semafor. */
error = _lwsem_destroy(&default_ppp.PPP_SEM);
if(default_ppp.PPP_IF_HANDLE)
{
/* Unregister PPP interface. */
error = RTCS_if_remove(default_ppp.PPP_IF_HANDLE);
}
if(default_ppp.PPP_IO_DRIVER_HANDLE)
{
/* Close PPP driver. */
error = _iopcb_close(default_ppp.PPP_IO_DRIVER_HANDLE);
}
if(default_ppp.PPP_DEV_HANDLE)
{
/* Close PPP driver. */
error = fclose(default_ppp.PPP_DEV_HANDLE);
}
if(default_ppp.PPP_CON_DEV_HANDLE)
{
/* Close Close PPP_DEVICE. */
error = fclose(default_ppp.PPP_CON_DEV_HANDLE);
}
if(error)
{
printf("\nSome error happend during closing PPP connection.\n");
}
else
{
printf("\nPPP connection closed.\n");
}
return RTCS_ERROR;
}
}
