示例#1
0
文件: dhcp.c 项目: dafyddcrosby/L4OS
// something has timed out, handle this
static void dhcp_timeout(struct dhcp_state *state)
{
  DEBUGF(DHCP_DEBUG, ("dhcp_timeout()\n"));
  if ((state->state == DHCP_BACKING_OFF) || (state->state == DHCP_SELECTING))
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): restarting discovery\n"));
    dhcp_discover(state);
  }
  else if (state->state == DHCP_REQUESTING)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n"));
    if (state->tries <= 5)
    {
      dhcp_select(state);
    }
    else
    {
      DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): REQUESTING, releasing, restarting\n"));
      dhcp_release(state);
      dhcp_discover(state);
    }
  }
  else if (state->state == DHCP_CHECKING)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): CHECKING, ARP request timed out\n"));
    if (state->tries <= 1)
    {
      dhcp_check(state);
    }
    // no ARP replies on the offered address,
    // looks like the IP address is indeed free
    else
    {
      dhcp_bind(state);
    }
  }
  else if (state->state == DHCP_RENEWING)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): RENEWING, DHCP request timed out\n"));
    dhcp_renew(state);
  }
  else if (state->state == DHCP_REBINDING)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): REBINDING, DHCP request timed out\n"));
    if (state->tries <= 8)
    {
      dhcp_rebind(state);
    }
    else
    {
      DEBUGF(DHCP_DEBUG, ("dhcp_timeout(): REBINDING, release, restart\n"));
      dhcp_release(state);
      dhcp_discover(state);
    }
  }
}
示例#2
0
__task void tcp_task (void) {
  /* Main Thread of the TcpNet. This task should have */
  /* the lowest priority because it is always READY. */
  dhcp_tout = DHCP_TOUT;
  while (1) {
    main_TcpNet();
    dhcp_check ();
    os_tsk_pass();
  }
}
示例#3
0
int main (void) {
  /* Main Thread of the TcpNet */

  init ();
  LEDrun = __TRUE;
  dhcp_tout = DHCP_TOUT;
  while (1) {
    timer_poll ();
    main_TcpNet ();
    dhcp_check ();
    blink_led ();
  }
}
示例#4
0
/*****************************************************************************
** Function name:		U16 tcp_task (void)
**
** Descriptions:		envia dados para o servidor TCP
*****************************************************************************/
void tcp_task(void)
{
	static U32 tcp_timer 	= 0u;
	U8 buf_udp[100],i;
			
	/****************** instantâneo ********************************/

#if USE_TCP_SERVER 	/*Comunicação TCP SERVER será usada?*/

	U8 ip[4];

	#if USE_PCK_SERV 
	static U32 cnt_tcp_serv = 0u;

	if(tcp_state.bit.dataToSend)
 	{						
		tcp_state.bit.dataToSend = __FALSE;
		cnt_tcp_serv = 0;

		//if(tcp_buf[0] == 0)		
	 		//sprintf((char*)tcp_buf,"%02X.%02X.%02X.%02X.%02X.%02X\r\n\0",own_hw_adr[0],own_hw_adr[1],own_hw_adr[2],own_hw_adr[3],own_hw_adr[4],own_hw_adr[5]);
		
		//tcpSend((char*)tcp_buf, strlen((const char*)tcp_buf), tcp_server_soc, CMD_SEND_TO_SERVER);
		//memset(tcp_buf,0,sizeof(tcp_buf));
	}
	#endif

#endif

	/****************** a cada 100ms *******************************/

	if(!tick)
		return;
	++tcp_timer;
	dhcp_check();

	/****************** a cada 1s **********************************/

	if((tcp_timer%TASK_1S))
		return;

#if USE_TCP_CLIENT
	
	if(!(tcp_timer%TASK_5S)) 
	{
		/*Pacote UDP de identificação*/
		sprintf((char*)buf_udp,"%s %u.%u.%u.%u %02X.%02X.%02X.%02X.%02X.%02X %s %s %u.%u.%u.%u %u.%u.%u.%u\r\n\0",lhost_name,MY_IP[0],MY_IP[1],MY_IP[2],MY_IP[3],
		own_hw_adr[0],own_hw_adr[1],own_hw_adr[2],own_hw_adr[3],own_hw_adr[4],own_hw_adr[5], cfg.tcp.port_serv_rem, cfg.tcp.ip_serv_rem,
		MY_MASK[0], MY_MASK[1], MY_MASK[2], MY_MASK[3],  MY_GATEWAY[0], MY_GATEWAY[1], MY_GATEWAY[2], MY_GATEWAY[3]);	
										   

		if(!ftp_state.bit.UpdateTcp)
			udpSendBroadcast(buf_udp);
			//udpSendUnicast(buf_udp,cfg.tcp.ip_app);
	}

	if(!(tcp_timer%TASK_30S))	/*A cada 30s*/
	{ 
		/*Mantém o link ativo*/
		//if(tcp_get_state (tcp_client_soc[0]) == TCP_STATE_CONNECT)
		//{
			sprintf(buf_tx,"LOK OK\r\n\0");
			for(i=0;i<MAX_NUM_SOC;i++)
				tcpSend (buf_tx, strlen(buf_tx), tcp_client_soc[i], CMD_SEND_TO_CLIENT);
			//tcpSend (buf_tx, strlen(buf_tx), tcp_client_soc[0], CMD_SEND_TO_CLIENT);
		//}
	}

#endif


#if USE_TCP_SERVER && USE_PCK_SERV 	/*Comunicação TCP SERVER será usada?*/
		
	if(!(++cnt_tcp_serv % atoi(cfg.tcp.interval_packet_serv)))
		tcp_state.bit.dataToSend = __TRUE;

#endif

#if USE_TCP_SERVER	/*Comunicação TCP SERVER será usada?*/

	/*Analisa estado de comunicação com o servidor externo*/
	if(tcp_get_state (tcp_server_soc) != TCP_STATE_CONNECT)
	{
		tcp_state.bit.serverConnected = __FALSE; 
		inet_aton((U8*)cfg.tcp.ip_serv_rem,ip);
		tcp_connect(tcp_server_soc,ip,atoi(cfg.tcp.port_serv_rem),atoi(cfg.tcp.port_serv_loc));
		
	}else
		tcp_state.bit.serverConnected = __TRUE; 
	
#endif	

	/*Houve alteração das cenas via FTP?*/
	if(ftp_state.bit.UpdateScene)	
	{
		printf ("[Scene config via FTP]\r\r");
		fflush(stdout);
		ftp_state.bit.UpdateScene = __FALSE;
		init_scene(0xFF);
	}

	if(ftp_state.bit.UpdateFileCfg)
	{
		printf ("[CFG.CFG configurado via FTP]\r\r");
		fflush(stdout);
		ftp_state.bit.UpdateFileCfg = __FALSE;
		read_file_cfg();
	}
	
	/*Houve alteração das configurações TCP via FTP?*/
	if(ftp_state.bit.UpdateTcp)
	{
		printf ("[TCP Config via FTP..Reiniciando]\r\r");
		fflush(stdout);
				
#if USE_TCP_CLIENT	
		for(i=0;i<MAX_NUM_SOC;i++)
			tcp_close (tcp_client_soc[i]);
#endif
#if USE_TCP_SERVER	
		tcp_close (tcp_server_soc);
#endif
		LPC_WDT->WDTC = 0x003FFFF;	/*0.5s*/
		wdt_feed();
		while(1);
	}			
}
示例#5
0
文件: dhcp.c 项目: dafyddcrosby/L4OS
/**
 * Match incoming DHCP messages against a DHCP client, and trigger its state machine
 */
static void dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port)
{
  struct dhcp_state *state = (struct dhcp_state *)arg;
  struct dhcp_msg *reply_msg = (struct dhcp_msg *)p->payload;
  DEBUGF(DHCP_DEBUG, ("dhcp_recv()\n"));
  DEBUGF(DHCP_DEBUG, ("pbuf->len = %u\n", p->len));
  DEBUGF(DHCP_DEBUG, ("pbuf->tot_len = %u\n", p->tot_len));
  state->p = p;
  if (reply_msg->op == DHCP_BOOTREPLY)
  {
    DEBUGF(DHCP_DEBUG, ("state->netif->hwaddr = %02x:%02x:%02x:%02x:%02x:%02x\n",
      state->netif->hwaddr[0], state->netif->hwaddr[1], state->netif->hwaddr[2],
      state->netif->hwaddr[3], state->netif->hwaddr[4], state->netif->hwaddr[5]));
    // TODO: Add multi network interface support, look up the targetted
    // interface here.
    if ((state->netif->hwaddr[0] == reply_msg->chaddr[0]) &&
        (state->netif->hwaddr[1] == reply_msg->chaddr[1]) &&
        (state->netif->hwaddr[2] == reply_msg->chaddr[2]) &&
        (state->netif->hwaddr[3] == reply_msg->chaddr[3]) &&
        (state->netif->hwaddr[4] == reply_msg->chaddr[4]) &&
        (state->netif->hwaddr[5] == reply_msg->chaddr[5]))
    {
      // check if the transaction ID matches
      if (get_reply_xid(reply_msg) == state->xid)
      {
        // option fields could be unfold?
        if (dhcp_unfold_reply(state) == ERR_OK)
        {
          u8_t *options_ptr = NULL;
          DEBUGF(DHCP_DEBUG, ("searching DHCP_OPTION_MESSAGE_TYPE\n")); 
          options_ptr = dhcp_get_option_ptr(state, DHCP_OPTION_MESSAGE_TYPE);
          if (options_ptr != NULL)
          {
            u8_t msg_type = dhcp_get_option_byte(options_ptr + 2);
            if (msg_type == DHCP_ACK)
            {
              DEBUGF(DHCP_DEBUG, ("DHCP_ACK received\n")); 
              if (state->state == DHCP_REQUESTING)
              {
                dhcp_handle_ack(state);
                state->request_timeout = 0;
#if DHCP_DOES_ARP_CHECK
                dhcp_check(state);
#else
                dhcp_bind(state);
#endif
              }
              else if ((state->state == DHCP_REBOOTING) || (state->state == DHCP_REBINDING) ||(state->state == DHCP_RENEWING))
              {
                state->request_timeout = 0;
                dhcp_bind(state);
              }
            }
            // received a DHCP_NAK in appropriate state?
            else if ((msg_type == DHCP_NAK) &&
              ((state->state == DHCP_REBOOTING) || (state->state == DHCP_REQUESTING) || 
              (state->state == DHCP_REBINDING) || (state->state == DHCP_RENEWING  )))
            {
              DEBUGF(DHCP_DEBUG, ("DHCP_NAK received\n")); 
              state->request_timeout = 0;
              dhcp_handle_nak(state);
            }
            // received a DHCP_OFFER in DHCP_SELECTING state?
            else if ((msg_type == DHCP_OFFER) && (state->state == DHCP_SELECTING))
            {
              DEBUGF(DHCP_DEBUG, ("DHCP_OFFER received in DHCP_SELECTING state\n")); 
              state->request_timeout = 0;
              dhcp_handle_offer(state);
            }
          }
          else
          {
            DEBUGF(DHCP_DEBUG, ("DHCP_OPTION_MESSAGE_TYPE option not found\n")); 
          }
          dhcp_free_reply(state);
        }
      }
      else
      {
        DEBUGF(DHCP_DEBUG, ("reply_msg->xid=%x does not match with state->xid=%x\n",
          get_reply_xid(reply_msg), state->xid));     
      }
    }
    else
    {
      DEBUGF(DHCP_DEBUG, ("hardware address did not match\n"));     
      DEBUGF(DHCP_DEBUG, ("reply_msg->chaddr = %02x:%02x:%02x:%02x:%02x:%02x\n",
        reply_msg->chaddr[0], reply_msg->chaddr[1], reply_msg->chaddr[2],
        reply_msg->chaddr[3], reply_msg->chaddr[4], reply_msg->chaddr[5]));
    }
  }
  else
  {
    DEBUGF(DHCP_DEBUG, ("not a DHCP reply message, but type %u\n", reply_msg->op));
  }

  pbuf_free(p);
}