/*---------------------------------------------------------------------------*/ 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); // 设置数据接收时的回调函数 // }