/*--------------------------------------------------------*/
void udp_client_process(void){
/******************** lock the Scheduler ************************/
cyg_scheduler_lock();
/****************************************************************/
static struct ctimer backoff_timer;
PRINTF("UDP client started\n");
set_global_address();
print_local_addresses();
client_conn = udp_new(NULL, UIP_HTONS(UDP_SERVER_PORT), NULL);
udp_bind(client_conn, UIP_HTONS(UDP_CLIENT_PORT));
PRINTF("Created a connection with the server ");
PRINT6ADDR(&client_conn->ripaddr);
PRINTF(" local/remote port %u/%u\n",
UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));
ctimer_set(&backoff_timer,SEND_TIME,send_packet,NULL);
// PRINTF(" local/remote port %u/%u\n", client_conn->lport, client_conn->rport);
void* message = NULL;
/******************** unlock the Scheduler ************************/
cyg_scheduler_unlock();
/****************************************************************/
while(1){
// cyg_thread_yield();
message = cyg_mbox_tryget (mbox_out_tcpip_handle);
MyEvent_t* msg_local = message ;
if ( message != NULL){
cyg_handle_t* event_handlePtr;
event_handlePtr = (cyg_handle_t*) msg_local-> dataPtr;
if( cyg_thread_self() == *event_handlePtr){
tcpip_handler();
}
}
cyg_thread_yield();
}
}
void DNS_daemon(cyg_addrword_t data)
{
DNSSERVER *new_active_srv;
int port = NAMESERVER_PORT;
int first_loop = 1;
int recv_len = 0;
int i, cmd, dns_sleep, ret;
struct timeval tv = {1, 0};
time_t now;
char packet[PACKETSZ+MAXDNAME+RRFIXEDSZ];
DNS_DBGPRINT(DNS_DEBUG_OFF, "%s\n", __FUNCTION__);
ret = dnsMasqstart(port);
if (ret < 0)
{
DNS_DBGPRINT(DNS_DEBUG_OFF, "%s(): Line%d failed to start up\n", __FUNCTION__, __LINE__);
return;
}
activeserver = &dns_servers[0];
dns_running = 1;
dns_sleep = 0;
while (dns_running)
{
int ready, maxfd = 0;
fd_set rset;
DNSHEADER *header;
cyg_thread_delay(10);
if ((cmd = (int )cyg_mbox_tryget(dns_mbox_id)) != 0)
{
switch(cmd)
{
case DNS_SIGHUP:
ret = dnsMasqstart(port);
if (ret < 0)
{
DNS_DBGPRINT(DNS_DEBUG_OFF, "%s(): Line%d failed to start up\n", __FUNCTION__, __LINE__);
dns_running = 0;
return;
}
dns_sleep = 0;
break;
case DNS_SHUTDOWN: // do we need to return ??
dnsMasqstop();
dns_sleep = 1;
break;
default:
break;
}
}
if (dns_sleep)
{
cyg_thread_delay(100);
continue;
}
/* do init stuff only first time round. */
if (first_loop)
{
first_loop = 0;
ready = 0;
}
else
{
FD_ZERO(&rset);
maxfd = 0;
for (i=0; i<dns_servers_num; i++)
{
if (dns_servers[i].fd > 0)
{
FD_SET(dns_servers[i].fd, &rset);
if (dns_servers[i].fd > maxfd)
maxfd = dns_servers[i].fd;
}
}
for (i=0; i<recv_infaces_num; i++)
{
if (recv_infaces[i].fd > 0)
{
FD_SET(recv_infaces[i].fd, &rset);
if (recv_infaces[i].fd > maxfd)
maxfd = recv_infaces[i].fd;
}
}
ready = select(maxfd+1, &rset, NULL, NULL, &tv); /* NONBLOCKING */
if(ready <= 0)
{
if (DNSDebugLevel > DNS_DEBUG_OFF) {
DNS_DBGPRINT(DNS_DEBUG_ERROR, "%s(): select() return %d\n", __FUNCTION__, ready);
cyg_thread_delay(100);
} else
cyg_thread_delay(2);
continue;
}
}
now = time(NULL);
if (ready == 0)
continue; /* no sockets ready */
// check dns query from querist
for (i=0; i<recv_infaces_num; i++)
{
if (recv_infaces[i].fd > 0)
{
if (FD_ISSET(recv_infaces[i].fd, &rset))
{
// request packet, deal with query
MYSOCKADDR queryaddr;
size_t queryaddrlen = sizeof(queryaddr);
FD_CLR(recv_infaces[i].fd, &rset);
recv_len = recvfrom(recv_infaces[i].fd, packet, PACKETSZ, 0, &queryaddr.sa, &queryaddrlen);
queryaddr.sa.sa_family = recv_infaces[i].addr.sa.sa_family;
header = (DNSHEADER *)packet;
if (recv_len >= (int)sizeof(DNSHEADER) && !header->qr)
{
activeserver = dnsMasqprocessquery(recv_infaces[i].fd, &queryaddr, header, recv_len,
activeserver, now);
}
}
}
}
// check dns reply from dns server
for (i=0; i<dns_servers_num; i++)
{
if (dns_servers[i].fd > 0)
{
if (FD_ISSET(dns_servers[i].fd, &rset))
{
FD_CLR(dns_servers[i].fd, &rset);
recv_len = recvfrom(dns_servers[i].fd, packet, PACKETSZ, 0, NULL, NULL);
new_active_srv = dnsMasqprocessreply(dns_servers[i].fd, packet, recv_len, now);
if (new_active_srv != NULL)
activeserver = new_active_srv;
}
}
}
}
}
int pptp_ctrlconn_open(PPTP_INFO *pInfo)
{
struct pptp_cmd *cmd;
fd_set fdset;
int max_fd;
struct timeval tv = {1, 0};
int n;
int first = 1;
if (pptp_ctrlconn_connect(pInfo) != 0)
return -1;
while (!pptp_ctrlconn_connected(pInfo))
{
if ((cmd = (struct pptp_cmd *)cyg_mbox_tryget(pInfo->msgq_id)) != 0)
{
switch (cmd->op)
{
case PPTP_CMD_STOP:
pptp_ctrlconn_disconnect(pInfo);
pInfo->state = PPTP_STATE_STOP;
return -1;
case PPTP_CMD_HANGUP:
pptp_ctrlconn_disconnect(pInfo);
if (pptp_ctrlconn_connect(pInfo) != 0)
return -1;
break;
case PPTP_CMD_TIMER:
pptp_timer_action(pInfo);
break;
default:
break;
}
}
FD_ZERO(&fdset);
FD_SET(pInfo->ctrl_sock, &fdset);
max_fd = pInfo->ctrl_sock + 1;
n = select(max_fd, &fdset, 0, 0, &tv);
if (n < 0)
{
pptp_ctrlconn_disconnect(pInfo);
pInfo->state = PPTP_STATE_STOP;
return -1;
}
if (n == 0)
continue;
if (FD_ISSET(pInfo->ctrl_sock, &fdset))
{
pptp_ctrlconn_process(pInfo);
FD_CLR(pInfo->ctrl_sock, &fdset);
}
if (first && pInfo->ctrlconn_state == PPTP_CTRLCONN_STATE_CONNECTED)
{
if (pptp_ctrlconn_call(pInfo) == 0)
first = 0;
}
}
pInfo->call_id = pInfo->ctrl_conn->call->call_id;
pInfo->peer_call_id = pInfo->ctrl_conn->call->peer_call_id;
if (pptp_gre_open(pInfo) != 0)
{
pptp_ctrlconn_disconnect(pInfo);
return -1;
}
pInfo->state = PPTP_STATE_GRE;
if (PppEth_Start(&pInfo->if_ppp) < 0)
return -1;
pInfo->task_flag |= PPTP_TASKFLAG_PPP;
pInfo->state = PPTP_STATE_PPP;
return 0;
}
