/*---------------------------------------------------------------------------*/
void
dhcpc_init(const void *mac_addr, int mac_len)
{
uip_ipaddr_t addr;
s.mac_addr = mac_addr;
s.mac_len = mac_len;
s.state = STATE_INITIAL;
uip_ipaddr(&addr, 255,255,255,255);
s.conn = udp_new(&addr, UIP_HTONS(DHCPC_SERVER_PORT), NULL);
if(s.conn != NULL)
{
udp_bind(s.conn, UIP_HTONS(DHCPC_CLIENT_PORT));
}
PT_INIT(&s.pt);
}
PROCESS_THREAD(raven_relay_process, ev, data) {
uip_ipaddr_t ipaddr;
PROCESS_POLLHANDLER(pollhandler());
PROCESS_EXITHANDLER(exithandler());
// see: http://senstools.gforge.inria.fr/doku.php?id=contiki:examples
PROCESS_BEGIN();
PRINTF("Relay process startup.\r\n");
// wait 3 second, in order to have the IP addresses well configured
etimer_set(&udp_periodic_timer, CLOCK_CONF_SECOND*3);
// wait until the timer has expired
PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_TIMER);
// Define Address of the server that receives our heartbeats.
// TODO: Make this dynamic
#ifdef UDP_ADDR_A
uip_ip6addr(&ipaddr,
UDP_ADDR_A,UDP_ADDR_B,UDP_ADDR_C,UDP_ADDR_D,
UDP_ADDR_E,UDP_ADDR_F,UDP_ADDR_G,UDP_ADDR_H);
#else /* UDP_ADDR_A */
uip_ip6addr(&ipaddr,0xbbbb,0,0,0,0xd69a,0x20ff,0xfe07,0x7664);
#endif /* UDP_ADDR_A */
udpconn = udp_new(NULL, HTONS(0), NULL);
//udpconn = udp_new(&ipaddr, HTONS(0xF0B0+1), NULL);
udp_bind(udpconn, HTONS(0xF0B0));
// udp_attach(udpconn, NULL);
PRINTF("Created connection with remote peer ");
PRINT6ADDR(&udpconn->ripaddr);
PRINTF("\r\nlocal/remote port %u/%u\r\n", HTONS(udpconn->lport),HTONS(udpconn->rport));
print_local_addresses();
etimer_set(&udp_periodic_timer, 60*CLOCK_SECOND);
while(1){
PRINTF("--- Relay: Waiting for events.\r\n");
// tcpip_poll_udp(udpconn);
PROCESS_WAIT_EVENT();
// PROCESS_YIELD();
udphandler(ev, data);
}
PROCESS_END();
}
PROCESS_THREAD(udp_server_process, ev, data)
{
PROCESS_BEGIN();
PRINTF("UDP server started\n");
server_conn = udp_new(NULL, UIP_HTONS(3001), NULL);
udp_bind(server_conn, UIP_HTONS(3000));
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event) {
tcpip_handler();
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(viztool_process, ev, data)
{
PROCESS_BEGIN();
server_conn = udp_new(NULL, UIP_HTONS(0), NULL);
udp_bind(server_conn, UIP_HTONS(VIZTOOL_UDP_PORT));
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event) {
tcpip_handler();
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(udp_server_process, ev, data)
{
#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)
static struct sensors_sensor *b1;
static struct sensors_sensor *b2;
#endif
PROCESS_BEGIN();
putstring("Starting UDP server\n");
#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)
putstring("Button 1: Print RIME stats\n");
putstring("Button 2: Reboot\n");
#endif
#if SERVER_RPL_ROOT
create_dag();
#endif
server_conn = udp_new(NULL, UIP_HTONS(0), NULL);
udp_bind(server_conn, UIP_HTONS(3000));
PRINTF("Listen port: 3000, TTL=%u\n", server_conn->ttl);
#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)
b1 = sensors_find(BUTTON_1_SENSOR);
b2 = sensors_find(BUTTON_2_SENSOR);
#endif
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event) {
tcpip_handler();
#if (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON)
} else if(ev == sensors_event && data != NULL) {
if(data == b1) {
print_stats();
} else if(data == b2) {
watchdog_reboot();
}
#endif /* (CONTIKI_TARGET_SENSINODE && BUTTON_SENSOR_ON) */
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
struct uip_udp_conn *
udp_broadcast_new(uint16_t port, void *appstate)
{
uip_ipaddr_t addr;
struct uip_udp_conn *conn;
#if NETSTACK_CONF_WITH_IPV6
uip_create_linklocal_allnodes_mcast(&addr);
#else
uip_ipaddr(&addr, 255,255,255,255);
#endif /* NETSTACK_CONF_WITH_IPV6 */
conn = udp_new(&addr, port, appstate);
if(conn != NULL) {
udp_bind(conn, port);
}
return conn;
}
/**
* Select a DHCP server offer out of all offers.
*
* Simply select the first offer received, ignore others
*/
static err_t dhcp_select(struct dhcp_state *state)
{
err_t result;
u32_t msecs;
DEBUGF(DHCP_DEBUG, ("dhcp_select()\n"));
// create and initialize the DHCP message header
result = dhcp_create_request(state);
if (result == ERR_OK)
{
dhcp_option(state, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN);
dhcp_option_byte(state, DHCP_REQUEST);
dhcp_option(state, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
dhcp_option_short(state, 576);
/* MUST request the offered IP address */
dhcp_option(state, DHCP_OPTION_REQUESTED_IP, 4);
dhcp_option_long(state, ntohl(state->offered_ip_addr.addr));
dhcp_option(state, DHCP_OPTION_SERVER_ID, 4);
dhcp_option_long(state, ntohl(state->server_ip_addr.addr));
dhcp_option(state, DHCP_OPTION_PARAMETER_REQUEST_LIST, 3);
dhcp_option_byte(state, DHCP_OPTION_SUBNET_MASK);
dhcp_option_byte(state, DHCP_OPTION_ROUTER);
dhcp_option_byte(state, DHCP_OPTION_BROADCAST);
dhcp_option_trailer(state);
pbuf_realloc(state->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + state->options_out_len);
udp_bind(state->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
udp_connect(state->pcb, IP_ADDR_BROADCAST, DHCP_SERVER_PORT);
udp_send(state->pcb, state->p_out);
// reconnect to any (or to server here?!)
udp_connect(state->pcb, IP_ADDR_ANY, DHCP_SERVER_PORT);
dhcp_delete_request(state);
}
state->tries++;
msecs = state->tries < 4 ? state->tries * 1000 : 4 * 1000;
state->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
DEBUGF(DHCP_DEBUG, ("dhcp_select(): request timeout %u msecs\n", msecs));
dhcp_set_state(state, DHCP_REQUESTING);
return result;
}
struct serial *
serial_init(void)
{
static struct serial serial;
serial.fUpcb = udp_new();
if (!serial.fUpcb)
assert("udp_new");
u16_t port = AOS06_PORT;
if (udp_bind(serial.fUpcb, &netif_default->ip_addr, port))
assert(!"udp_bind");
if (udp_connect(serial.fUpcb, &netif_default->gw, port))
assert(!"udp_connect");
udp_recv(serial.fUpcb, &serial_recv_handler, &serial);
return &serial;
}
/**
* @brief Initializes the udp pcb for TFTP
* @param None
* @retval None
*/
void tftpd_init(unsigned short port)
{
err_t err;
/* create a new UDP PCB structure */
UDPpcb = udp_new();
if (UDPpcb)
{
/* Bind this PCB to port 69 */
err = udp_bind(UDPpcb, IP_ADDR_ANY, port);
if (err == ERR_OK)
{
/* TFTP server start */
udp_recv(UDPpcb, recv_callback_tftp, NULL);
}
}
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(ledsUDPServer_process, ev, data)
{
static struct uip_udp_conn *localconn;
PROCESS_BEGIN();
/* Create a local connection structure :
* - Remote IP: 0.0.0.0 (all accepted).
* - Remote port: 0 (all accepted).
*/
localconn = udp_new(&uip_all_zeroes_addr, 0, NULL);
/* Bind to the local port. */
udp_bind(localconn,uip_htons(local_port));
PRINTF("I listen the UDP port %u\n",uip_ntohs(localconn->lport));
while (1)
{
PRINTF("I wait a new request\n");
PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event);
/* Here, a new TCP/IP event occurred ! */
/* A good packet is :
* - With data.
* - With at least "preambleSize + 1" bytes.
* - Packet start with the good preamble.
*/
if(uip_newdata() &&
uip_datalen() >= (preambleSize + 1) &&
!strncmp(uip_appdata,preamble,preambleSize))
{
PRINTF("I received a LED toggling request.\n");
{
char *data = (char *)uip_appdata;
int led = 0;
switch (data[4]) {
case '1': led = LEDS_BLUE; break;
case '2': led = LEDS_GREEN; break;
case '3': led = LEDS_RED; break;
default : PRINTF("I can't find the good LED...\n"); continue;
}
leds_toggle(led);
}
}
}
PROCESS_END();
}
bool NetworkSocket_StartListening(NetworkSocket * networkSocket)
{
bool result = false;
if (networkSocket)
{
if ((networkSocket->SocketType & NetworkSocketType_UDP) == NetworkSocketType_UDP)
{
networkSocket->Socket = udp_new(NULL, 0, NULL);
if (networkSocket->Socket)
{
udp_bind(networkSocket->Socket, uip_htons(networkSocket->Port));
result = true;
}
}
}
return result;
}
int udp_bind_connect(char *src, int sport, char *dest, int dport,
struct sockaddr_in *serv)
{
int sock;
sock = udp_bind(src, sport);
if (sock < 0)
return sock;
fill_sockaddr(serv, dest, dport);
if (connect(sock, (struct sockaddr *) serv, sizeof(*serv)) < 0)
{
LOGL(0, "udp_bind_connect: failed: bind(): %s", strerror(errno));
return -1;
}
LOG("New UDP socket %d connected to %s:%d", sock, inet_ntoa(serv->sin_addr),
ntohs(serv->sin_port));
return sock;
}
static socket_error_t lwipv4_socket_bind(struct socket *sock, const struct socket_addr *address, const uint16_t port)
{
err_t err = ERR_OK;
ip_addr_t a;
switch (sock->family){
case SOCKET_DGRAM:
a.addr = socket_addr_get_ipv4_addr(address);
err = udp_bind((struct udp_pcb *)sock->impl, &a, port);
break;
case SOCKET_STREAM:
a.addr = socket_addr_get_ipv4_addr(address);
err = tcp_bind((struct tcp_pcb *)sock->impl, &a, port);
break;
default:
return SOCKET_ERROR_BAD_FAMILY;
}
return lwipv4_socket_error_remap(err);
}
/*
* Log a debug message by sending it within a UDP message.
*/
void snmp_info(char* format, ...)
{
static struct uip_udp_conn *udp_con = NULL;
if (udp_con == NULL) {
udp_con = udp_new(NULL, UIP_HTONS(LOGGING_PORT), NULL);
uip_ip6addr(&udp_con->ripaddr, 0xaaaa, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001);
udp_bind(udp_con, UIP_HTONS(3000));
}
va_list args;
va_start(args, format);
static char buf[BUF_LEN];
memset(buf, 0, BUF_LEN);
vsprintf(buf, format, args);
va_end(args);
uip_udp_packet_send(udp_con, buf, strlen(buf));
}
static void initer_slave() {
err_t err;
struct ip_addr ipSend;
//lwip_init();
pUdpConnection = udp_new();
IP4_ADDR(&ipSend, 255, 255, 255, 255);
pUdpConnection->multicast_ip = ipSend;
pUdpConnection->remote_ip = ipSend;
pUdpConnection->remote_port = 8000;
if(pUdpConnection == NULL) {
os_printf("\nCould not create new udp socket... \n");
}
err = udp_bind(pUdpConnection, IPADDR_ANY, 8000);
udp_recv(pUdpConnection, handle_udp_recv_slave, pUdpConnection);
led_init("01");
}
err_t dhcp_renew(struct dhcp_state *state)
{
err_t result;
u16_t msecs;
DEBUGF(DHCP_DEBUG, ("dhcp_renew()\n"));
dhcp_set_state(state, DHCP_RENEWING);
// create and initialize the DHCP message header
result = dhcp_create_request(state);
if (result == ERR_OK)
{
dhcp_option(state, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN);
dhcp_option_byte(state, DHCP_REQUEST);
dhcp_option(state, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);
dhcp_option_short(state, 576);
#if 0
dhcp_option(state, DHCP_OPTION_REQUESTED_IP, 4);
dhcp_option_long(state, ntohl(state->offered_ip_addr.addr));
#endif
#if 0
dhcp_option(state, DHCP_OPTION_SERVER_ID, 4);
dhcp_option_long(state, ntohl(state->server_ip_addr.addr));
#endif
dhcp_option_trailer(state);
pbuf_realloc(state->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + state->options_out_len);
udp_bind(state->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
udp_connect(state->pcb, &state->server_ip_addr, DHCP_SERVER_PORT);
udp_send(state->pcb, state->p_out);
dhcp_delete_request(state);
}
state->tries++;
// back-off on retries, but to a maximum of 20 seconds
msecs = state->tries < 10 ? state->tries * 2000 : 20 * 1000;
state->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
DEBUGF(DHCP_DEBUG, ("dhcp_renew(): request timeout %u msecs\n", msecs));
return result;
}
static void server(int port) {
int i, s;
Octstr *ping, *pong, *from;
s = udp_bind(port,"0.0.0.0");
pong = octstr_create(PONG);
if (s == -1)
panic(0, "Couldn't set up client socket.");
for (i = 0; i < TIMES; ++i) {
if (udp_recvfrom(s, &ping, &from) == -1)
panic(0, "Couldn't receive ping");
info(0, "Got <%s> from <%s:%d>", octstr_get_cstr(ping),
octstr_get_cstr(udp_get_ip(from)),
udp_get_port(from));
if (udp_sendto(s, pong, from) == -1)
panic(0, "Couldn't send pong.");
}
}
void UDP_Test(void)
{
struct udp_pcb *UdpPcb;
struct ip_addr ipaddr;
struct pbuf *p;
p = pbuf_alloc(PBUF_RAW,sizeof(UDPData),PBUF_RAM);
if(p==NULL)
return;
p->payload=(void *)UDPData;
UdpPcb=udp_new(); /* 建立UDP 通信的控制块(pcb) */
udp_bind(UdpPcb,IP_ADDR_ANY,8080); /* 绑定本地IP 地址 */
IP4_ADDR(&ipaddr,192, 168, 10, 100);
udp_sendto(UdpPcb,p,&ipaddr,8080); /* 将收到的数据再发送出去 */
udp_recv(UdpPcb,UDP_Receive,NULL); /* 设置数据接收时的回调函数 */
LED1(1);
LED2(1);
LED3(1);
}
void init_value_broadcast(void)
{
syslog(LOG_INFO, "Value Broadcast init");
// this wrapper macro is needed to expand HXB_GROUP_RAW before uip_ip6addr, which is a macro
// it's ugly as day, but it's the least ugly solution i found
#define PARSER_WRAP(addr, ...) uip_ip6addr(addr, __VA_ARGS__)
PARSER_WRAP(&server_ipaddr, HXB_GROUP_RAW);
#undef PARSER_WRAP
print_local_addresses();
/* new connection with remote host */
client_conn = udp_new(NULL, UIP_HTONS(HXB_PORT), NULL);
uip_ipaddr_copy(&client_conn->ripaddr, &server_ipaddr);
udp_bind(client_conn, UIP_HTONS(HXB_PORT));
syslog(LOG_DEBUG, "Created a connection " LOG_6ADDR_FMT ", local/remote port %u/%u", LOG_6ADDR_VAL(client_conn->ripaddr), UIP_HTONS(client_conn->lport), UIP_HTONS(client_conn->rport));
}
void UDP_Config(void)
{
if(ETH_BSP_Config() == ETH_ERROR) CriticalError(ERR_ETH_CONFIG);
LwIP_Init();
delay(500);
IP4_ADDR(&ip_addr_tx,192,9,206,251);
if((pudp_pcb = udp_new()) == NULL) CriticalError(ERR_UDP_NEW);
if((udp_bind(pudp_pcb,IP_ADDR_ANY,RX_PORT) != ERR_OK)) CriticalError(ERR_UDP_BIND);
udp_recv(pudp_pcb,&udp_rx_handler,NULL);
if(!(pOut = pbuf_alloc(PBUF_TRANSPORT,sizeof(tx_udp_msg),PBUF_RAM))) CriticalError(ERR_POUT_NEW);
}
static int udp_open (PAL_HANDLE *hdl, const char * type, const char * uri,
int access, int share, int create, int options)
{
char buf[PAL_SOCKADDR_SIZE];
int len = strlen(uri);
if (len >= PAL_SOCKADDR_SIZE)
return -PAL_ERROR_TOOLONG;
memcpy(buf, uri, len + 1);
if (!memcmp(type, "udp.srv:", 8))
return udp_bind(hdl, buf, create);
if (!memcmp(type, "udp:", 4))
return udp_connect(hdl, buf);
return -PAL_ERROR_NOTSUPPORT;
}
void init_udp() {
err_t err;
struct ip_addr ipSend;
lwip_init();
pUdpConnection = udp_new();
IP4_ADDR(&ipSend, 255, 255, 255, 255);
pUdpConnection->multicast_ip = ipSend;
pUdpConnection->remote_ip = ipSend;
pUdpConnection->remote_port = port;
if(pUdpConnection == NULL) {
os_printf("\nCould not create new udp socket... \n");
}
err = udp_bind(pUdpConnection, IP_ADDR_ANY, port);
udp_recv(pUdpConnection, handle_udp_recv, pUdpConnection);
os_timer_disarm(&waitTimer);
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(ipv6_process, ev, data)
{
PROCESS_BEGIN();
// Set the local address
uip_ip6addr(&my_addr, 0, 0, 0, 0, 0, 0, 0, 0);
uip_ds6_set_addr_iid(&my_addr, &uip_lladdr);
uip_ds6_addr_add(&my_addr, 0, ADDR_MANUAL);
// Setup the destination address
uiplib_ipaddrconv(RECEIVER_ADDR, &dest_addr);
// Add a "neighbor" for our custom route
// Setup the default broadcast route
uiplib_ipaddrconv(ADDR_ALL_ROUTERS, &bcast_ipaddr);
uip_ds6_nbr_add(&bcast_ipaddr, &bcast_lladdr, 0, NBR_REACHABLE);
uip_ds6_route_add(&dest_addr, 128, &bcast_ipaddr);
// Setup a udp "connection"
client_conn = udp_new(&dest_addr, UIP_HTONS(RECEIVER_PORT), NULL);
if (client_conn == NULL) {
// Too many udp connections
// not sure how to exit...stupid contiki
}
udp_bind(client_conn, UIP_HTONS(3001));
etimer_set(&periodic_timer, 10*CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
if (etimer_expired(&periodic_timer)) {
send_handler(ev, data);
etimer_restart(&periodic_timer);
} else if (ev == tcpip_event) {
recv_handler();
}
}
PROCESS_END();
}
PROCESS_THREAD(sender_process, ev, data)
{
static struct etimer periodic;
static struct ctimer backoff_timer;
PROCESS_BEGIN();
// PROCESS_PAUSE();
set_global_address();
PRINTF("The sender process begins.\n");
print_local_addresses();
/* new connection with remote host */
sender_conn = udp_new(NULL, UIP_HTONS(UDP_SINK_PORT), NULL);
if(sender_conn == NULL)
{
PRINTF("No UDP connection available, exiting the process!\n");
PROCESS_EXIT();
}
udp_bind(sender_conn, UIP_HTONS(UDP_SENDER_PORT));
PRINTF("Created a connection with the server ");
PRINT6ADDR(&sender_conn->ripaddr);
PRINTF(" local/remote port %u/%u\n", UIP_HTONS(sender_conn->lport),
UIP_HTONS(sender_conn->rport));
etimer_set(&periodic, SEND_INTERVAL * CLOCK_SECOND);
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event)
tcpip_handler();
if(etimer_expired(&periodic))
{
etimer_reset(&periodic);
ctimer_set(&backoff_timer, RANDWAIT * CLOCK_SECOND, send_packet, NULL);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(trickle_protocol_process, ev, data)
{
PROCESS_BEGIN();
PRINTF("Trickle protocol started\n");
uip_create_linklocal_allnodes_mcast(&ipaddr); /* Store for later */
trickle_conn = udp_new(NULL, UIP_HTONS(TRICKLE_PROTO_PORT), NULL);
udp_bind(trickle_conn, UIP_HTONS(TRICKLE_PROTO_PORT));
PRINTF("Connection: local/remote port %u/%u\n",
UIP_HTONS(trickle_conn->lport), UIP_HTONS(trickle_conn->rport));
token = 0;
trickle_timer_config(&tt, IMIN, IMAX, REDUNDANCY_CONST);
trickle_timer_set(&tt, trickle_tx, &tt);
/*
* At this point trickle is started and is running the first interval. All
* nodes 'agree' that token == 0. This will change when one of them randomly
* decides to generate a new one
*/
etimer_set(&et, NEW_TOKEN_INTERVAL);
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event) {
tcpip_handler();
} else if(etimer_expired(&et)) {
/* Periodically (and randomly) generate a new token. This will trigger
* a trickle inconsistency */
if((random_rand() % NEW_TOKEN_PROB) == 0) {
token++;
PRINTF("At %lu: Generating a new token 0x%02x\n",
(unsigned long)clock_time(), token);
trickle_timer_reset_event(&tt);
}
etimer_set(&et, NEW_TOKEN_INTERVAL);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(udp_client_process, ev, data)
{
static struct etimer et;
uip_ipaddr_t ipaddr;
PROCESS_BEGIN();
PRINTF("UDP client process started\n");
#if UIP_CONF_ROUTER
set_global_address();
#endif
print_local_addresses();
set_connection_address(&ipaddr);
/* new connection with remote host */
client_conn = udp_new(&ipaddr, UIP_HTONS(3000), NULL);
udp_bind(client_conn, UIP_HTONS(3001));
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));
etimer_set(&et, SEND_INTERVAL);
while(1)
{
PROCESS_YIELD();
if(etimer_expired(&et))
{
timeout_handler();
etimer_restart(&et);
}
else if(ev == tcpip_event)
{
tcpip_handler();
}
}
PROCESS_END();
}
/**
* Starts SNMP Agent.
* Allocates UDP pcb and binds it to IP_ADDR_ANY port 161.
*/
void
snmp_init(void)
{
struct snmp_msg_pstat *msg_ps;
u8_t i;
ip_addr_t *ip_addr_any4;
#if LWIP_IPV6
ip_addr_any4 = ((ip_addr_t *)&ip6_addr_any);
snmp1_pcb = udp_new_ip6();
#else
ip_addr_any4 = IP_ADDR_ANY;
snmp1_pcb = udp_new();
#endif
if (snmp1_pcb != NULL)
{
udp_recv(snmp1_pcb, snmp_recv, (void *)SNMP_IN_PORT);
udp_bind(snmp1_pcb, ip_addr_any4, SNMP_IN_PORT);
}
msg_ps = &msg_input_list[0];
for (i=0; i<SNMP_CONCURRENT_REQUESTS; i++)
{
msg_ps->state = SNMP_MSG_EMPTY;
msg_ps->error_index = 0;
msg_ps->error_status = SNMP_ES_NOERROR;
msg_ps++;
}
trap_msg.pcb = snmp1_pcb;
#ifdef SNMP_PRIVATE_MIB_INIT
/* If defined, rhis must be a function-like define to initialize the
* private MIB after the stack has been initialized.
* The private MIB can also be initialized in tcpip_callback (or after
* the stack is initialized), this define is only for convenience. */
SNMP_PRIVATE_MIB_INIT();
#endif /* SNMP_PRIVATE_MIB_INIT */
/* The coldstart trap will only be output
if our outgoing interface is up & configured */
snmp_coldstart_trap();
}
int TftpClient::get(char *rem_file, char *loc_file)
{
struct udp_pcb * pcb = udp_new();
err = udp_bind(pcb, IP_ADDR_ANY, loc_port);
if(err != ERR_OK){
error(lwip_strerr(err), false);
return -1;
}
fd = open(loc_file, O_WRONLY);
blkno = 1;
// Craft the initial get request with appropriate mode
int bufsize = strlen(rem_file) + 4 + (mode == MODE_NETASCII ? strlen("netascii") : strlen("octet"));
char *pkt = (char *)safe_malloc(bufsize);
memset(pkt, 0, bufsize);
u16_t *opcode = (u16_t *) pkt;
*opcode = htons(1);
memcpy(pkt+2, rem_file, strlen(rem_file)+1);
if(mode == MODE_NETASCII)
memcpy(pkt+3+strlen(rem_file), "netascii", strlen("netascii"));
else
memcpy(pkt+3+strlen(rem_file), "octet", strlen("octet"));
// Set the packet recv handler
udp_recv(pcb, hndl_pkt, this);
// Send the packet
struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, bufsize, PBUF_ROM);
p->payload = pkt;
udp_sendto(pcb, p, &rem_host, rem_port);
// Block the thread until the request is satisfied
sys_sem_new(&get_wait, 0);
sys_arch_sem_wait(&get_wait, 0);
sys_sem_free(&get_wait);
udp_remove(pcb);
//pbuf_free(p);
}
void ICACHE_FLASH_ATTR
discover_bulbs(void) {
struct udp_pcb *pcb;
uint8_t buff[36];
struct pbuf *p;
err_t ret;
LED_ON();
// Using the RAW interface to LWIP
// the socket and netconn interfaces didn't receive broadcast packets
pcb = udp_new();
ret = udp_bind(pcb, IP_ADDR_ANY, BROADCAST_PORT);
if (ret != ERR_OK) {
os_printf("[discover] Error bind %d\r\n", ret);
return;
}
udp_recv(pcb, my_udp_recv, NULL);
// Create pbuf for a new outgoing packet
p = pbuf_alloc(PBUF_TRANSPORT, 36, PBUF_RAM);
if (p == NULL) {
os_printf("[discover] error pbuf_alloc %d\r\n", ret);
return;
}
getBroadcastPkt((uint8_t *)p->payload, 36);
ret = udp_sendto(pcb, p, IP_ADDR_BROADCAST, BROADCAST_PORT);
if (ret != ERR_OK) {
os_printf("[discover] Error sending %d\r\n", ret);
pbuf_free(p);
return;
}
os_printf("[discover] Broadcast sent\r\n");
pbuf_free(p);
// MUST wait a given timeout for messages to be received before
// tearing down the connection - udp_remove() will disable the callback
vTaskDelay(500/portTICK_RATE_MS);
LED_OFF();
vTaskDelay(2000/portTICK_RATE_MS);
udp_remove(pcb);
}
void UDP_broadcast(void)
{
struct udp_pcb *UdpPcb;
struct ip_addr ipaddr;
struct pbuf *p;
p = pbuf_alloc(PBUF_RAW,sizeof(UDPData),PBUF_RAM);
printf("\nUDP broadcast\n");
if(p==NULL)
return;
p->payload=(void *)UDPData; ///给pbuf初始化
UdpPcb=udp_new(); // 建立UDP 通信的控制块(pcb)
udp_bind(UdpPcb,IP_ADDR_ANY,8080); // 绑定本地IP 地址
IP4_ADDR(&ipaddr,255, 255, 255, 255);
udp_sendto(UdpPcb,p,&ipaddr,8080); // 将收到的数据再发送出去 //
udp_sendto(UdpPcb,p,&ipaddr,8080);
udp_sendto(UdpPcb,p,&ipaddr,8080);
udp_recv(UdpPcb,UDP_Receive,NULL); // 设置数据接收时的回调函数 //
}
