自学教程：C++ udp_send函数代码示例

/** * Function: senddata * Description: 串口客户端UDP发送数据的接口函数 * @param conn 当前UDP的连接 * @param serial_no UDP连接对应的串口号 * @param data_length 要发送的数据长度**/uint8_t senddata(struct udp_pcb *conn,uint8_t serial_no,uint32_t data_length) {    uint32_t send_length = 0;	struct pbuf *udp_data_packet;	uint32_t loc = 0;	err_t err_status;	do {				if(data_length >= UDP_MSS) {            send_length = UDP_MSS;        } else {            send_length = data_length;        }		udp_data_packet = pbuf_alloc(PBUF_RAW,send_length,PBUF_RAM);		if(!udp_data_packet){			printf("serial udp memory allocate/n/r");			return 0;		}        memset(udp_data_packet->payload,0,send_length);		memcpy(udp_data_packet->payload,&serial_client.client_queue_data_buf[serial_no][loc],send_length);		err_status = udp_send(conn,udp_data_packet);		loc += send_length;        data_length -= send_length;		if(udp_data_packet){			pbuf_free(udp_data_packet);			udp_data_packet = NULL;		}    } while(data_length > 0);	if(serial_client.client_queue_data_buf[serial_no]){		free(serial_client.client_queue_data_buf[serial_no]);		serial_client.client_queue_data_buf[serial_no] = NULL;	}	return 1;}

void receive_tweet(char* buffer, struct sockaddr_in* server){    struct sockaddr_in client;    int transfered = 0, timeoutcount = 0;    /* Get message from message server */    if (!udp_send(sock, "Gimmeh!", server, sizeof(struct sockaddr_in)))        error_and_exit("Cannot send message to server", __FILE__, __LINE__);    do {        transfered = udp_receive(sock, buffer, BUFSIZE, &client, sizeof(client));        if (transfered == -1)         {            if (errno == EAGAIN || errno == EWOULDBLOCK)             {                ++timeoutcount;                if (timeoutcount >= MAX_TIMEOUTS)                 {                    printf("Maximum timeouts exceeded. Server is considered dead.");                    exit(0);                }                printf("Server timed out (%d)./n", timeoutcount);            }            error_and_exit("Cannot read from server", __FILE__, __LINE__);        }         else if (transfered == 0)         {            error_and_exit("Server has shut down", __FILE__, __LINE__);        }    } while (transfered <= 0);     if (server->sin_addr.s_addr != client.sin_addr.s_addr)        error_and_exit("Received message from unexpected server", __FILE__, __LINE__);}

/** * Send an RTP packet to a peer * * @param rs     RTP Socket * @param dst    Destination address * @param ext    Extension bit * @param marker Marker bit * @param pt     Payload type * @param ts     Timestamp * @param mb     Payload buffer * * @return 0 for success, otherwise errorcode */int rtp_send(struct rtp_sock *rs, const struct sa *dst, bool ext,	     bool marker, uint8_t pt, uint32_t ts, struct mbuf *mb){	size_t pos;	int err;	if (!rs || !mb)		return EINVAL;	if (mb->pos < RTP_HEADER_SIZE) {		DEBUG_WARNING("rtp_send: buffer must have space for"			      " rtp header (pos=%u, end=%u)/n",			      mb->pos, mb->end);		return EBADMSG;	}	mbuf_advance(mb, -RTP_HEADER_SIZE);	pos = mb->pos;	err = rtp_encode(rs, ext, marker, pt, ts, mb);	if (err)		return err;	if (rs->rtcp)		rtcp_sess_tx_rtp(rs->rtcp, ts, mbuf_get_left(mb));	mb->pos = pos;	return udp_send(rs->sock_rtp, dst, mb);}

int main (void){    zctx_t *ctx = zctx_new ();    udp_t *udp = udp_new (PING_PORT_NUMBER);        byte buffer [PING_MSG_SIZE];    zmq_pollitem_t pollitems [] = {{ NULL, udp_handle (udp), ZMQ_POLLIN, 0 }};        //  Send first ping right away    uint64_t ping_at = zclock_time ();        while (!zctx_interrupted) {        long timeout = (long) (ping_at - zclock_time ());        if (timeout < 0)            timeout = 0;        if (zmq_poll (pollitems, 1, timeout * ZMQ_POLL_MSEC) == -1)            break;              //  Interrupted        //  Someone answered our ping        if (pollitems [0].revents & ZMQ_POLLIN)            udp_recv (udp, buffer, PING_MSG_SIZE);                if (zclock_time () >= ping_at) {            puts ("Pinging peers...");            buffer [0] = '!';            udp_send (udp, buffer, PING_MSG_SIZE);            ping_at = zclock_time () + PING_INTERVAL;        }    }    udp_destroy (&udp);    zctx_destroy (&ctx);    return 0;}

/** * Send some data on a RAW or UDP pcb contained in a netconn * Called from netconn_send * * @param msg the api_msg_msg pointing to the connection */voiddo_send(struct api_msg_msg *msg){  if (!ERR_IS_FATAL(msg->conn->err)) {    if (msg->conn->pcb.tcp != NULL) {      switch (NETCONNTYPE_GROUP(msg->conn->type)) {#if LWIP_RAW      case NETCONN_RAW:        if (msg->msg.b->addr == NULL) {          msg->conn->err = raw_send(msg->conn->pcb.raw, msg->msg.b->p);        } else {          msg->conn->err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, msg->msg.b->addr);        }        break;#endif#if LWIP_UDP      case NETCONN_UDP:        if (msg->msg.b->addr == NULL) {          msg->conn->err = udp_send(msg->conn->pcb.udp, msg->msg.b->p);        } else {          msg->conn->err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, msg->msg.b->addr, msg->msg.b->port);        }        break;#endif /* LWIP_UDP */      default:        break;      }    }  }  TCPIP_APIMSG_ACK(msg);}

// This is a very weird function, look at udpCheckReceiveFork() in matlab.c for the "why"int udpmsg_receive(udpmsg *packet) {	 char recv_buf[MAXMSGLENGTH+10];	 char senderIP[16]; // "xxx.xxx.xxx.xxx/0"	 int ret = 0;	 if(udp_check(0)) {		 udp_read(recv_buf, sizeof(recv_buf), senderIP);		 //	printf("%s/n", senderIP);		 // First if clause determines whether message is from Psychtoolbox		 if (!strcmp(senderIP, macIP)) {			 if(strlen(recv_buf)>10 && recv_buf[9]==' ' && strcmp(recv_buf,last_recv)!=0) {				 strcpy(last_recv, recv_buf);				 strncpy(packet->id, recv_buf, 9);				 packet->id[9] = 0;				 strcpy(packet->msg, recv_buf+10);				 if (strcmp(packet->msg,"RECEIVED")==0)				   packet->received = 1;				 else if (strcmp(packet->msg,"EXECUTED")==0)				   packet->executed = 1;				 else {					 /* if it is a new message confirm its receipt */					 strcpy(recv_buf+10, "RECEIVED");					 udp_send(recv_buf, macIP);				 }				 				 ret = 1;			 }       		 }	 }	 return ret; }

static voiddo_send(struct api_msg_msg *msg){  if (msg->conn->pcb.tcp != NULL) {    switch (msg->conn->type) {#if LWIP_RAW    case NETCONN_RAW:      raw_send(msg->conn->pcb.raw, msg->msg.p);      break;#endif#if LWIP_UDP    case NETCONN_UDPLITE:      /* FALLTHROUGH */    case NETCONN_UDPNOCHKSUM:      /* FALLTHROUGH */    case NETCONN_UDP:      udp_send(msg->conn->pcb.udp, msg->msg.p);      break;#endif /* LWIP_UDP */    case NETCONN_TCP:      break;    }  }  sys_mbox_post(msg->conn->mbox, NULL);}

int udp_broadcast (const char *address,                   unsigned int port,                   const paxos_message_t *message){  udp_client_t client;  int sock;  int ret;  if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0)    return(-1);  ret = 1;  if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &ret, sizeof(int)) < 0) {    close(sock);    return(-1);  }  memset(&(client.addr), 0, sizeof(struct sockaddr_in));  client.addr.sin_family = AF_INET;  client.addr.sin_addr.s_addr = inet_addr(address);  //client.addr.sin_addr.s_addr = inet_addr("127.255.255.255");  //addr.sin_addr.s_addr = inet_addr("255.255.255.255");  client.addr.sin_port = htons(port);  client.addrlen = sizeof(struct sockaddr_in);  ret = udp_send(sock, &client, message);  close(sock);  return(ret != sizeof(paxos_message_t));}

socket_error_t lwipv4_socket_send(struct socket *socket, const void * buf, const size_t len){    err_t err = ERR_VAL;    switch(socket->family) {    case SOCKET_DGRAM: {        struct pbuf *pb = pbuf_alloc(PBUF_TRANSPORT,len,PBUF_RAM);        socket_event_t e;        socket_api_handler_t handler = socket->handler;        err = pbuf_take(pb, buf, len);        if (err != ERR_OK)            break;        err = udp_send(socket->impl, pb);        pbuf_free(pb);        if (err != ERR_OK)            break;        //Notify the application that the transfer is queued at the MAC layer        e.event = SOCKET_EVENT_TX_DONE;        e.sock = socket;        e.i.t.sentbytes = len;        socket->event = &e;        handler();        socket->event = NULL;        break;    }    case SOCKET_STREAM:        err = tcp_write(socket->impl,buf,len,TCP_WRITE_FLAG_COPY);        break;    }    return lwipv4_socket_error_remap(err);}

static err_t dhcp_release(struct dhcp_state *state){  err_t result;  u16_t msecs;  DEBUGF(DHCP_DEBUG, ("dhcp_release()/n"));  // and idle DHCP client  dhcp_set_state(state, DHCP_OFF);  // 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_RELEASE);    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++;  msecs = state->tries < 10 ? state->tries * 1000 : 10 * 1000;  state->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;  DEBUGF(DHCP_DEBUG, ("dhcp_release(): request timeout %u msecs/n", msecs));  // remove IP address from interface  netif_set_ipaddr(state->netif, IP_ADDR_ANY);  netif_set_gw(state->netif, IP_ADDR_ANY);  netif_set_netmask(state->netif, IP_ADDR_ANY);  return result;}

/** * Function: send_packet * Description: 向NTP服务器发送NTP数据包，请求时间更新 * @param usd 标志位，目前统一使用1**/int send_packet(int usd) {    //char ntp_header[200];	struct pbuf *ntp_packet;	err_t err_result;	memset(&ntp_client,0,sizeof(ntp_client));	ntp_packet = pbuf_alloc(PBUF_RAW,sizeof(ntp_client),PBUF_RAM);	if(!ntp_packet){		printf("ntp pbuf allocate failed/n/r");		return -1;	}	NTP_Init();	memset(ntp_packet->payload,0,sizeof(ntp_client));	memcpy(ntp_packet->payload,(void*)&ntp_client,sizeof(ntp_client));	    /*客户端给服务器端发送NTP协议数据包*/		err_result = udp_send(ntp_udp_client,ntp_packet);	if(err_result == ERR_OK){   //数据发送成功		//释放pbuf空间		pbuf_free(ntp_packet);	}else{		printf("ntp packet send failed/n/r");		return -1;	}	is_open_ntp_request_timer = 1;	ntp_send_request_time = sCount;	//printf("NTP request has sent over/n/r");}

// decline astatic err_t dhcp_decline(struct dhcp_state *state){  err_t result = ERR_OK;  u16_t msecs;  DEBUGF(DHCP_DEBUG, ("dhcp_decline()/n"));  dhcp_set_state(state, DHCP_BACKING_OFF);  // 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_DECLINE);    dhcp_option(state, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN);    dhcp_option_short(state, 576);    dhcp_option_trailer(state);    // resize pbuf to reflect true size of options    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++;  msecs = 10*1000;  state->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;  DEBUGF(DHCP_DEBUG, ("dhcp_decline(): request timeout %u msecs/n", msecs));  return result;}

/* * 函数名：updd_Send * 描述  ：发送udp数据包 * 输入  ：无 * 输出  : 无 * 调用  ：外部调用 */void udpd_Send(void){	struct udp_pcb *UdpPcb;   struct ip_addr ipaddr;   struct pbuf *p;	err_t err = ERR_Mine;	//测试用		p = pbuf_alloc(PBUF_RAW,sizeof(UDPData),PBUF_RAM);   p->payload=(void *)UDPData;    	UdpPcb = udp_new(); 	udp_bind(UdpPcb,IP_ADDR_ANY,6000);       /* 绑定本地IP 地址 */   IP4_ADDR(&ipaddr,192,168,1,122);     err = udp_connect(UdpPcb,&ipaddr,6001);   /* 连接远程主机 */ 		if(err == ERR_OK)	{		err = ERR_Mine;	//测试用		err = udp_send(UdpPcb, p);	}		udp_disconnect(UdpPcb);	pbuf_free(p);	udp_remove(UdpPcb);}

int main(int argc, char** argv){	if(argc != 4  && argc != 2){		printf("/nSYTAX: <(s)end/(r)ecv> xxx.xxx.xxx.xxx  /"Message (if sending)/"");		exit(0);	}	if(argv[1][0] == 's'){		char *addr;		char *msg;		size_t msg_len = strlen(argv[3])+1;		int add_len = strlen(argv[2]);		msg=malloc(msg_len);		strcpy(msg,argv[3]);		addr = malloc(add_len);		memcpy(addr,argv[2],add_len);		udp_send(addr,d_port,d_port,&msg,&msg_len);	}	else if (argv[1][0] == 'r'){		size_t size;		size = (size_t) 512;		char* msg;		msg = malloc(size);		udp_listen(d_port,&msg,size);		printf("Received : /n%s",msg);	}	return 0;}

int mgcp_send_dummy(struct mgcp_endpoint *endp){	static char buf[] = { DUMMY_LOAD };	return udp_send(endp->net_end.rtp.fd, &endp->net_end.addr,			endp->net_end.rtp_port, buf, 1);}

void client_init(void){    struct udp_pcb *upcb;    struct pbuf *p;    SET_IP4_ADDR(&ip_udp_server,UDP_SERVER_IP);    /* Create a new UDP control block  */    upcb = udp_new();    p = pbuf_alloc(PBUF_TRANSPORT, sizeof(Sent), PBUF_RAM);    p->payload = (void*)Sent;    upcb->local_port = 5;    udp_connect(upcb, &ip_udp_server, UDP_SERVER_PORT);    udp_send(upcb, p);    /* Reset the upcb */    udp_disconnect(upcb);    /* Bind the upcb to any IP address and the UDP_PORT port*/    udp_bind(upcb, IP_ADDR_ANY, 5);    udp_recv(upcb, udp_client_callback, NULL);    /* Free the p buffer */    pbuf_free(p);}

void *_send(void *args){    (void) args;    msg_init_queue(_send_msg_queue, MAIN_QUEUE_SIZE);    char *arg[4];    char *cmd = "udp_send";    char *dst = "abcd::1";    char *port = "8888";    char rank[12];    arg[0] = cmd;    arg[1] = dst;    arg[2] = port;    while(1) {        xtimer_sleep(2);        if (gnrc_rpl_instances[0].state && gnrc_rpl_instances[0].dodag.my_rank == GNRC_RPL_ROOT_RANK) {            return NULL;        }        if (gnrc_rpl_instances[0].state) {            memset(rank, 0, sizeof(rank));            sprintf(rank, "%u", gnrc_rpl_instances[0].dodag.my_rank);            arg[3] = rank;            udp_send(4, arg);        }    }    return NULL;}

extern int send_rescueack(unsigned short no, unsigned short lo){	ebuf_t *buf = NULL;	int acksocket;	char tftpnull;	int res, i;	/*	 * Open a UDP socket to the TFTP server	 */	acksocket = udp_socket(UDP_PROTO_TFTP);	res = udp_bind(acksocket, 69);	if (res < 0) {		return res;	}	udp_connect(acksocket, ackport);	for (i = 0; i < 1; i++) {		buf = udp_alloc();		if (!buf)			return -1;		/*		 * Send the data		 */		ebuf_append_u16_be(buf, no);		ebuf_append_u16_be(buf, lo);		ebuf_append_bytes(buf,&tftpnull, 0);		udp_send(acksocket ,buf, tftpipto);	}	if (buf)		udp_free(buf);	udp_close(acksocket);	return 0;}

void mdns_probe(){	len_self = _update_hook_self(config.name);	len_instance = _update_hook_instance(config.name);	len_arpa = _update_hook_arpa(config.comm.ip);	int i;	for(i=0; i<3; i++)	{		uint8_t *head = BUF_O_OFFSET(buf_o_ptr);		uint8_t *tail = head;				uint16_t id = rand() & 0xffff;		tail = _serialize_query(tail, id, MDNS_FLAGS_AA, 0, 1, 0, 0);		tail = _serialize_question(tail, hook_self, MDNS_TYPE_ANY, MDNS_CLASS_INET);				udp_send(config.mdns.socket.sock, BUF_O_BASE(buf_o_ptr), tail-head);		// wait 250ms second		uint32_t tick = systick_uptime();		while(systick_uptime() - tick < SNTP_SYSTICK_RATE / 4)			;		//FIXME listen for collisions with hook_self	}}

static int _tftp_close(tftp_info_t *info){    ebuf_t *buf;    const char *emsg = "transfer cancelled";	/* some error message */    if (info->tftp_socket == -1) return 0;    if (info->tftp_filemode == FILE_MODE_READ) {	buf = udp_alloc();	if (buf) {	    /* If we're on the EOF packet, just send an ack */	    if (info->tftp_lastblock) {		ebuf_append_u16_be(buf,TFTP_OP_ACK);		ebuf_append_u16_be(buf,info->tftp_blknum);		}	    else {		ebuf_append_u16_be(buf,TFTP_OP_ERROR);		ebuf_append_u16_be(buf,TFTP_ERR_DISKFULL);		ebuf_append_bytes(buf,emsg,strlen(emsg)+1);		}	    udp_send(info->tftp_socket,buf,info->tftp_ipaddr);	    }	}    else {	/* Just flush out the remaining write data, if any */	_tftp_writemore(info);	}    udp_close(info->tftp_socket);    info->tftp_socket = -1;    return 0;}

// Helper function for send/sendto to handle UDP packets.STATIC mp_uint_t lwip_udp_send(lwip_socket_obj_t *socket, const byte *buf, mp_uint_t len, byte *ip, mp_uint_t port, int *_errno) {    if (len > 0xffff) {        // Any packet that big is probably going to fail the pbuf_alloc anyway, but may as well try        len = 0xffff;    }    // FIXME: maybe PBUF_ROM?    struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);    if (p == NULL) {        *_errno = ENOMEM;        return -1;    }    memcpy(p->payload, buf, len);    err_t err;    if (ip == NULL) {        err = udp_send(socket->pcb.udp, p);    } else {        ip_addr_t dest;        IP4_ADDR(&dest, ip[0], ip[1], ip[2], ip[3]);        err = udp_sendto(socket->pcb.udp, p, &dest, port);    }    pbuf_free(p);    if (err != ERR_OK) {        *_errno = error_lookup_table[-err];        return -1;    }    return len;}

static voidpxudp_pcb_forward_inbound(struct pxudp *pxudp){    struct pbuf *p;    u32_t timo;    err_t error;    if (!sys_mbox_valid(&pxudp->inmbox)) {        return;    }    timo = sys_mbox_tryfetch(&pxudp->inmbox, (void **)&p);    if (timo == SYS_MBOX_EMPTY) {        return;    }    error = udp_send(pxudp->pcb, p);    if (error != ERR_OK) {        DPRINTF(("%s: udp_send(pcb %p) err %d/n",                 __func__, (void *)pxudp, error));    }    pbuf_free(p);    /*     * If we enabled counting in pxudp_pcb_forward_outbound() check     * that we have (all) the reply(s).     */    if (pxudp->count > 0) {        --pxudp->count;        if (pxudp->count == 0) {            pxudp_pcb_expired(pxudp);        }    }}

int udp_send_all(int socket, struct in_addr *iface, const struct sockaddr* to, int to_len, int out_len){	struct ifconf	ifc;	char 		buf[1024] = { 0 };	struct ifreq	*ifr = 0;	struct in_addr	from;	int		i;	int		rc = 0;	char		ip[64];	/* Send through all interfaces */	ifc.ifc_len = sizeof(buf);	ifc.ifc_buf = buf;	ioctl(socket, SIOCGIFCONF, &ifc);	ifr = ifc.ifc_req;	for(i=0; i<(ifc.ifc_len/sizeof(*ifr)); i++) {		from.s_addr = ((struct sockaddr_in *)&ifr[i].ifr_addr)->sin_addr.s_addr;		if (iface->s_addr != INADDR_ANY && iface->s_addr != from.s_addr)			continue;		if (udp_send(socket, from, to, to_len, out_len) == 1) {			inet_ntop(AF_INET, &from.s_addr, ip, sizeof(ip));			wsdd_log(LOG_ERR, "Failed to send udp from %s/n", ip);			rc = -1;		}	}	return rc;}

/* send one packet (heartbeat) */int send_packet(void){	static long sequence;	auto char 	buf[128];	auto int 	length, retval;	#GLOBAL_INIT	{		sequence = 0;	}	/* fill the packet with interesting data (a sequence number) */	sequence++;	sprintf(buf, "SEQ=%ld",sequence);	length = strlen(buf) + 1;	/* send the packet */	retval = udp_send(&sock, buf, length);	if (retval < 0) {		printf("Error sending datagram!  Closing and reopening socket.../n");		if (sequence == 1) {			printf("   (initial ARP request may not have finished)/n");		}		sock_close(&sock);		if(!udp_open(&sock, LOCAL_PORT, resolve(REMOTE_IP), REMOTE_PORT, NULL)) {			printf("udp_open failed!/n");			exit(0);		}	}	tcp_tick(NULL);		return 1;}

static int msg_treatment(void){	int err = 0, msg_t = 0, i = 0;	char path[MAXLEN], *msg;	msg_st requete;	MD5_CTX context;	unsigned char md[MD5_DIGEST_LENGTH];	char mdascii[2*MD5_DIGEST_LENGTH+1];	char alert_msg[MAXLEN] = { "" };	/* receive message from mailbox */	err = msgrcv(file_id, &requete, sizeof(msg_st),			     TYPE_DTH_ASYNCH, 0);	if (err < 0) {		printf("message can't be received (%s)/n",		       strerror(err));		return -1;	}	msg = malloc(strlen(addr_interface_s) + MD5_SIZE +				strlen(requete.message) * sizeof(char));	/* extract path and message type */	sscanf(requete.message, "%s %d %254c", path, &msg_t, alert_msg);	printf("msg received => %s",requete.message);	if (debug)		printf("extract path=> %s/nextract message type=>%d/nalert notification=>%s/n", path, msg_t,alert_msg);	/* compute MD5 */	MD5_Init(&context);	MD5_Update(&context, path, strlen(path));	MD5_Final(md, &context);	/* Convert raw valure to ascii */	memset(mdascii, 0, 2*MD5_DIGEST_LENGTH);	for(i=0; i < MD5_DIGEST_LENGTH; i++)	{		sprintf(&(mdascii[i*2]), "%02x", md[i] );	}	/* create message */	sprintf(msg, "%s %s %s %s", addr_interface_s, mdascii, msg_type[msg_t],alert_msg);	if (debug)		printf("msg %s/n", msg);	/*send message */	if (debug)		printf("send msg %s/n", msg);	err = udp_send(msg);	if (err < 0)		printf("broadcast error, message can't be send (%s)/n",		       strerror(err));	free(msg);	return 0;}

int main(int argc, char** argv){    parse_args(argc, argv);    if(print_usage_flag) {        print_usage();        return 0;    }    init();    short accel[3], gyro[3], sensors[1];    long quat[4];    unsigned long timestamp;    unsigned char more[0];    struct pollfd fdset[1];    char buf[1];    // File descriptor for the GPIO interrupt pin    int gpio_fd = open(GPIO_INT_FILE, O_RDONLY | O_NONBLOCK);    // Create an event on the GPIO value file    memset((void*)fdset, 0, sizeof(fdset));    fdset[0].fd = gpio_fd;    fdset[0].events = POLLPRI;    while (1){        // Blocking poll to wait for an edge on the interrupt        if(!no_interrupt_flag) {            poll(fdset, 1, -1);        }        if (no_interrupt_flag || fdset[0].revents & POLLPRI) {            // Read the file to make it reset the interrupt            if(!no_interrupt_flag) {                read(fdset[0].fd, buf, 1);			}            int fifo_read = dmp_read_fifo(gyro, accel, quat, &timestamp, sensors, more);            if (fifo_read != 0) {                //printf("Error reading fifo./n");                continue;            }            float angles[NOSENTVALS];            rescale_l(quat, angles+9, QUAT_SCALE, 4);            // rescale the gyro and accel values received from the IMU from longs that the            // it uses for efficiency to the floats that they actually are and store these values in the angles array            rescale_s(gyro, angles+3, GYRO_SCALE, 3);            rescale_s(accel, angles+6, ACCEL_SCALE, 3);            // turn the quaternation (that is already in angles) into euler angles and store it in the angles array            euler(angles+9, angles);            if(!silent_flag && verbose_flag) {                printf("Yaw: %+5.1f/tPitch: %+5.1f/tRoll: %+5.1f/n", angles[0]*180.0/PI, angles[1]*180.0/PI, angles[2]*180.0/PI);            }            // send the values in angles over UDP as a string (in udp.c/h)            if(!no_broadcast_flag) {                udp_send(angles, 13);            }        }    }}

int main() {    int fd = udp_init_broadcast(8887);    char *sendtext = "UDP Test/n";    printf("Sending text:/n%s/n", sendtext);    udp_send(fd, sendtext, strlen(sendtext));    udp_close(fd);    return 0;}

void provSendPacket(const void* buffer, int len){	struct pbuf* p;	p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);	pbuf_take(p, buffer, len);	udp_send(eth_udppcb, p);	pbuf_free(p);}

int main(int argc, char *argv[]){	if(argc < 2)	{		printf("Usage ./main MD1AC44200003128/n");		return EXIT_FAILURE;	}	int 	prev_value = 100;	int 	recent_value = 1;	FILE*	stream;	char	request[1024], buf[1024], json[1024];	stream = fopen("config.ini", "r");	fread(buf, sizeof(char), sizeof(buf), stream);	fclose(stream);	printf("Bulb: %s/n", argv[1]);	while(1)	{		sprintf(request, "https://io.adafruit.com/api/feeds/qstation?x-aio-key=%s", buf);		recent_value = http_request(request);		if(prev_value != 100 && recent_value != prev_value)		{			if(recent_value == 2)			{				printf("Turn bulb off./n");				sprintf(json, "{/"iswitch/":/"0/",/"r/":/"255/",/"g/":/"255/",/"b/":/"255/",/"bright/":/"20/",/"cmd/":/"light_ctrl/",/"effect/":/"9/",/"sn_list/":[{/"sn/":/"%s/"}]}", argv[1]);				udp_send(json);			}			else if(recent_value == 3)			{				printf("Turn bulb on./n");				sprintf(json, "{/"iswitch/":/"1/",/"r/":/"255/",/"g/":/"255/",/"b/":/"255/",/"bright/":/"20/",/"cmd/":/"light_ctrl/",/"effect/":/"9/",/"sn_list/":[{/"sn/":/"%s/"}]}", argv[1]);				udp_send(json);			}			else printf("ERROR: Unknown value./n");		}		prev_value = recent_value;		sleep(10);	}	return EXIT_SUCCESS;}

inlineint udp_send(udp_sock& sock, const std::vector<char>& msg){    if(msg.size() == 0)        return 0;    return udp_send(sock, &msg[0], msg.size());}