/*---------------------------------------------------------------------------*/ static void handle_beacon_send_timer(struct net_buf *buf, void *p) { struct net_buf *mbuf; frame802154_t params; uint8_t len; mbuf = l2_buf_get_reserve(0); if(!mbuf) { return; } /* init to zeros */ memset(¶ms, 0, sizeof(params)); /* use packetbuf for sending ?? */ packetbuf_clear(mbuf); /* Build the FCF. */ params.fcf.frame_type = FRAME802154_BEACONFRAME; /* Insert IEEE 802.15.4 (2006) version bits. */ params.fcf.frame_version = FRAME802154_IEEE802154_2006; /* assume long for now */ params.fcf.src_addr_mode = FRAME802154_LONGADDRMODE; linkaddr_copy((linkaddr_t *)¶ms.src_addr, &linkaddr_node_addr); /* Set the source PAN ID to the global variable. */ params.src_pid = panid; params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE; params.dest_addr[0] = 0xFF; params.dest_addr[1] = 0xFF; params.dest_pid = 0xffff; params.seq = framer_802154_next_seqno(); /* Calculate beacon length and copy it to packetbuf */ beacon_payload_len = handler_802154_calculate_beacon_payload_length(beacon_payload, BEACON_PAYLOAD_BUFFER_SIZE); packetbuf_copyfrom(mbuf, beacon_payload, beacon_payload_len); /* Set payload and payload length */ params.payload = packetbuf_dataptr(mbuf); params.payload_len = packetbuf_datalen(mbuf); len = frame802154_hdrlen(¶ms); if(packetbuf_hdralloc(mbuf, len)) { frame802154_create(¶ms, packetbuf_hdrptr(mbuf), len); if(NETSTACK_RADIO.send(mbuf, packetbuf_hdrptr(mbuf), packetbuf_totlen(mbuf)) != RADIO_TX_OK) { l2_buf_unref(mbuf); return; } HANDLER_802154_STAT(handler_802154_stats.beacons_sent++); } }
/*---------------------------------------------------------------------------*/ static int output(struct channel *c) { const struct packetbuf_attrlist *a; int byteptr, len; uint8_t *hdrptr; struct raw_hdr *hdr; /* Compute the total size of the final header by summing the size of all attributes that are used on this channel. */ if(packetbuf_hdralloc(c->hdrsize + sizeof(struct raw_hdr)) == 0) { PRINTF("chameleon-raw: insufficient space for headers\n"); return 0; } hdr = (struct raw_hdr *)packetbuf_hdrptr(); hdr->channel[0] = c->channelno & 0xff; hdr->channel[1] = (c->channelno >> 8) & 0xff; hdrptr = ((uint8_t *)packetbuf_hdrptr()) + sizeof(struct raw_hdr); byteptr = 0; for(a = c->attrlist; a->type != PACKETBUF_ATTR_NONE; ++a) { #if CHAMELEON_WITH_MAC_LINK_ADDRESSES if(a->type == PACKETBUF_ADDR_SENDER || a->type == PACKETBUF_ADDR_RECEIVER) { /* Let the link layer handle sender and receiver */ PRINTF("%d.%d: pack_header leaving sender/receiver to link layer\n"); continue; } #endif /* CHAMELEON_WITH_MAC_LINK_ADDRESSES */ PRINTF("%d.%d: pack_header type %d, len %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], a->type, a->len); len = (a->len & 0xf8) + ((a->len & 7) ? 8: 0); if(PACKETBUF_IS_ADDR(a->type)) { const rimeaddr_t *rimeaddr; /* memcpy(&hdrptr[byteptr], (uint8_t *)packetbuf_attr_aget(a->type), len / 8);*/ rimeaddr = packetbuf_addr(a->type); hdrptr[byteptr] = rimeaddr->u8[0]; hdrptr[byteptr + 1] = rimeaddr->u8[1]; PRINTF("%d.%d: address %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], ((uint8_t *)packetbuf_addr(a->type))[0], ((uint8_t *)packetbuf_addr(a->type))[1]); } else { packetbuf_attr_t val; val = packetbuf_attr(a->type); memcpy(&hdrptr[byteptr], &val, len / 8); PRINTF("%d.%d: value %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], val); } byteptr += len / 8; } return 1; /* Send out packet */ }
/*---------------------------------------------------------------------------*/ static void packet_input(void) { #if NETSTACK_CONF_WITH_IP64 /* If NAT64 is enabled, IPv4 & ARP packets are sent to the IP64 module */ ethernet_header_t *hdr = (ethernet_header_t *)packetbuf_hdrptr(); if (hdr->et_protlen == UIP_HTONS(ETH_PROT_IP) || hdr->et_protlen == UIP_HTONS(ETH_PROT_ARP)) { IP64_INPUT(packetbuf_hdrptr(), packetbuf_totlen()); return; } #endif /* NETSTACK_CONF_WITH_IP64 */ if(NETSTACK_0_FRAMER.parse() < 0) { PRINTF("ieee8023_mac: failed to parse %u\n", (unsigned int)packetbuf_datalen()); #if IEEE8023_MAC_ADDRESS_FILTER } else if(!linkaddr6_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &linkaddr6_node_addr) && !linkaddr6_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &linkaddr6_null)) { /*\note The framer should have done the multicast address * translation from 0x33 0x33 0xXX... to the 802.3xx null */ PRINTF("ieee8023_mac: not for us\n"); #endif /* IEEE8023_MAC_ADDRESS_FILTER */ } else { int duplicate = 0; duplicate = mac_sequence_is_duplicate(); if(duplicate && ETH_SUPPORT_DUPLICATE_DETECTION) { /* Drop the packet. */ PRINTF("ieee8023_mac: drop duplicate link layer packet %u\n", packetbuf_attr(PACKETBUF_ATTR_PACKET_ID)); } else { mac_sequence_register_seqno(); } #if DEBUG int i; uint16_t original_datalen = packetbuf_totlen(); uint8_t *original_dataptr = packetbuf_hdrptr(); PRINTF("PKT[%u]:",original_datalen); for (i=0; i<original_datalen; i++) { PRINTF("%02x ",original_dataptr[i]); } PRINTF("\n"); #endif if(!(duplicate && ETH_SUPPORT_DUPLICATE_DETECTION)) { link_if_in(NETSTACK_8023); NETSTACK_0_NETWORK.input(); link_if_in(NETSTACK_NULL); } else { PRINTF("IEEE8023_MAC: drop duplicate\n"); } } }
/* called to send a beacon request */ void handler_802154_send_beacon_request(void) { struct net_buf *mbuf; frame802154_t params; uint8_t len; mbuf = l2_buf_get_reserve(0); if(!mbuf) { return; } /* init to zeros */ memset(¶ms, 0, sizeof(params)); /* use packetbuf for sending ?? */ packetbuf_clear(mbuf); /* Build the FCF. */ params.fcf.frame_type = FRAME802154_CMDFRAME; /* Insert IEEE 802.15.4 (2006) version bits. */ params.fcf.frame_version = FRAME802154_IEEE802154_2006; params.fcf.src_addr_mode = FRAME802154_NOADDR; params.fcf.dest_addr_mode = FRAME802154_SHORTADDRMODE; params.dest_addr[0] = 0xFF; params.dest_addr[1] = 0xFF; params.dest_pid = 0xffff; params.seq = chseqno; packetbuf_set_datalen(mbuf, 1); params.payload = packetbuf_dataptr(mbuf); /* set the type in the payload */ params.payload[0] = FRAME802154_BEACONREQ; params.payload_len = packetbuf_datalen(mbuf); len = frame802154_hdrlen(¶ms); if(packetbuf_hdralloc(mbuf, len)) { frame802154_create(¶ms, packetbuf_hdrptr(mbuf), len); if(NETSTACK_RADIO.send(mbuf, packetbuf_hdrptr(mbuf), packetbuf_totlen(mbuf)) != RADIO_TX_OK) { l2_buf_unref(mbuf); return; } HANDLER_802154_STAT(handler_802154_stats.beacons_reqs_sent++); } }
/*---------------------------------------------------------------------------*/ static int output(struct channel *c) { const struct packetbuf_attrlist *a; int byteptr, len; uint8_t *hdrptr; struct raw_hdr *hdr; /* Compute the total size of the final header by summing the size of all attributes that are used on this channel. */ packetbuf_hdralloc(c->hdrsize); hdrptr = packetbuf_hdrptr(); byteptr = 0; for(a = c->attrlist; a->type != PACKETBUF_ATTR_NONE; ++a) { PRINTF("%d.%d: pack_header type %s, len %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], packetbuf_attr_strings[a->type], a->len); len = (a->len & 0xf8) + ((a->len & 7) ? 8: 0); if(a->type == PACKETBUF_ADDR_SENDER || a->type == PACKETBUF_ADDR_RECEIVER || a->type == PACKETBUF_ADDR_ESENDER || a->type == PACKETBUF_ADDR_ERECEIVER) { const rimeaddr_t *rimeaddr; /* memcpy(&hdrptr[byteptr], (uint8_t *)packetbuf_attr_aget(a->type), len / 8);*/ rimeaddr = packetbuf_addr(a->type); hdrptr[byteptr] = rimeaddr->u8[0]; hdrptr[byteptr + 1] = rimeaddr->u8[1]; PRINTF("%d.%d: address %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], ((uint8_t *)packetbuf_addr(a->type))[0], ((uint8_t *)packetbuf_addr(a->type))[1]); } else { packetbuf_attr_t val; val = packetbuf_attr(a->type); memcpy(&hdrptr[byteptr], &val, len / 8); PRINTF("%d.%d: value %d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], val); } byteptr += len / 8; } packetbuf_hdralloc(sizeof(struct raw_hdr)); hdr = (struct raw_hdr *)packetbuf_hdrptr(); hdr->channel = c->channelno; return 1; /* Send out packet */ }
PROCESS_THREAD(rime_udp_process, ev, data) { static uip_ipaddr_t ipaddr; PROCESS_BEGIN(); broadcast_conn = udp_broadcast_new(HTONS(RIME_UDP_PORT), NULL); if(broadcast_conn == NULL) { PRINTF("rime-udp: Failed to allocate a broadcast connection!\n"); } uip_create_unspecified(&ipaddr); unicast_conn = udp_new(&ipaddr, HTONS(RIME_UDP_PORT), NULL); if(unicast_conn == NULL) { PRINTF("rime-udp: Failed to allocate a unicast connection!\n"); } udp_bind(unicast_conn, HTONS(RIME_UDP_PORT)); while(1) { PROCESS_WAIT_EVENT_UNTIL(ev == tcpip_event); if(uip_newdata()) { packetbuf_clear(); memmove(packetbuf_hdrptr(), uip_appdata, uip_datalen()); PRINTF("rime-udp: received %d bytes\n", uip_datalen()); receiver_callback(&rime_udp_driver); } } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ void adaptivesec_aead(uint8_t *key, int shall_encrypt, uint8_t *result, int forward) { uint8_t nonce[CCM_STAR_NONCE_LENGTH]; uint8_t *m; uint8_t m_len; uint8_t *a; uint8_t a_len; ccm_star_packetbuf_set_nonce(nonce, forward); a = packetbuf_hdrptr(); if(shall_encrypt) { #if AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES a_len = packetbuf_hdrlen() + packetbuf_attr(PACKETBUF_ATTR_UNENCRYPTED_BYTES); #else /* AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES */ a_len = packetbuf_hdrlen(); #endif /* AKES_NBR_WITH_GROUP_KEYS && PACKETBUF_WITH_UNENCRYPTED_BYTES */ m = a + a_len; m_len = packetbuf_totlen() - a_len; } else { a_len = packetbuf_totlen(); m = NULL; m_len = 0; } AES_128_GET_LOCK(); ADAPTIVESEC_SET_KEY(key); CCM_STAR.aead(nonce, m, m_len, a, a_len, result, adaptivesec_mic_len(), forward); AES_128_RELEASE_LOCK(); }
/*---------------------------------------------------------------------------*/ int rmh_send(struct rmh_conn *c, rimeaddr_t *to, uint8_t num_rexmit, uint8_t max_hops) { rimeaddr_t *nexthop; struct data_hdr *hdr; c->num_rexmit = num_rexmit; if(c->cb->forward == NULL) { return 0; } nexthop = c->cb->forward(c, &rimeaddr_node_addr, to, NULL, 0); if(nexthop == NULL) { PRINTF("rmh_send: no route\n"); return 0; } else { PRINTF("rmh_send: sending data\n"); if(packetbuf_hdralloc(sizeof(struct data_hdr))) { hdr = packetbuf_hdrptr(); rimeaddr_copy(&hdr->dest, to); rimeaddr_copy(&hdr->originator, &rimeaddr_node_addr); hdr->hops = 1; hdr->max_rexmits = num_rexmit; runicast_send(&c->c, nexthop, num_rexmit); } return 1; } }
/* -------------------------------------------------------------------- */ static void input_packet(void) { static struct packet_s reference_packet; static uint16_t last_number; static uint16_t rx_ok; static uint16_t rx_corrupt; struct packet_s *p = (struct packet_s *) packetbuf_hdrptr(); if(memcmp(p->filling, reference_packet.filling, sizeof(p->filling))) { /* corrupt packet detected */ rx_corrupt++; return; } if(last_number > p->number) { printf("Out of 100 packets %u seen, %u good, %u corrupt\n", rx_ok + rx_corrupt + (uint16_t)rimestats.badcrc, rx_ok, rx_corrupt + (uint16_t)rimestats.badcrc); rx_ok = 0; rx_corrupt = 0; rimestats.badcrc = 0; } rx_ok++; last_number = p->number; }
static void send_announcement(void *ptr) { struct xmac_hdr *hdr; int announcement_len; /* Set up the probe header. */ packetbuf_clear(); hdr = packetbuf_dataptr(); announcement_len = format_announcement((char *)hdr + sizeof(struct xmac_hdr)); if(announcement_len > 0) { packetbuf_set_datalen(sizeof(struct xmac_hdr) + announcement_len); hdr->dispatch = DISPATCH; hdr->type = TYPE_ANNOUNCEMENT; packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null); packetbuf_set_attr(PACKETBUF_ATTR_RADIO_TXPOWER, announcement_radio_txpower); if(NETSTACK_FRAMER.create() >= 0) { NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()); } } }
/*---------------------------------------------------------------------------*/ static int send_packet(void) { if(radio->send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) { return MAC_TX_OK; } return MAC_TX_ERR; }
/*---------------------------------------------------------------------------*/ int packetbuf_copyto(void *to) { if(packetbuf->hdrlen + packetbuf->datalen > PACKETBUF_SIZE) { return 0; } memcpy(to, packetbuf_hdrptr(), packetbuf->hdrlen); memcpy((uint8_t *)to + packetbuf->hdrlen, packetbuf_dataptr(), packetbuf->datalen); return packetbuf->hdrlen + packetbuf->datalen; }
/*---------------------------------------------------------------------------*/ int packetbuf_copyto(void *to) { if(hdrlen + buflen > PACKETBUF_SIZE) { return 0; } memcpy(to, packetbuf_hdrptr(), hdrlen); memcpy((uint8_t *)to + hdrlen, packetbuf_dataptr(), buflen); return hdrlen + buflen; }
/*---------------------------------------------------------------------------*/ static void send_packet(mac_callback_t sent, void *ptr) { int ret; if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) { ret = MAC_TX_OK; } else { ret = MAC_TX_ERR; } mac_call_sent_callback(sent, ptr, ret, 1); }
/*---------------------------------------------------------------------------*/ static int send_packet(void) { const rimeaddr_t *addr; addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER); PRINTF("rime-udp: Sending %d bytes to %d.%d\n", packetbuf_totlen(), addr->u8[RIMEADDR_SIZE-2], addr->u8[RIMEADDR_SIZE-1]); if(rimeaddr_cmp(&rimeaddr_null, addr)) { uip_udp_packet_send(broadcast_conn, packetbuf_hdrptr(), packetbuf_totlen()); } else { uip_ip6addr(&unicast_conn->ripaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0); uip_netif_addr_autoconf_set(&unicast_conn->ripaddr, (uip_lladdr_t *)addr); uip_udp_packet_send(unicast_conn, packetbuf_hdrptr(), packetbuf_totlen()); uip_create_unspecified(&unicast_conn->ripaddr); } return 1; }
/*---------------------------------------------------------------------------*/ static void send_packet(mac_callback_t sent_callback, void *ptr) { const rimeaddr_t *addr; addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER); PRINTF("rime-udp: Sending %d bytes to %d.%d\n", packetbuf_totlen(), addr->u8[0], addr->u8[1]); if(rimeaddr_cmp(&rimeaddr_null, addr)) { uip_udp_packet_send(broadcast_conn, packetbuf_hdrptr(), packetbuf_totlen()); mac_call_sent_callback(sent_callback, ptr, MAC_TX_OK, 1); } else { uip_ip6addr(&unicast_conn->ripaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0); uip_netif_addr_autoconf_set(&unicast_conn->ripaddr, (uip_lladdr_t *)addr); uip_udp_packet_send(unicast_conn, packetbuf_hdrptr(), packetbuf_totlen()); uip_create_unspecified(&unicast_conn->ripaddr); } return; }
/** * Send a probe packet. */ static void send_probe(void) { struct lpp_hdr *hdr; struct announcement_msg *adata; struct announcement *a; /* Set up the probe header. */ packetbuf_clear(); packetbuf_set_datalen(sizeof(struct lpp_hdr)); hdr = packetbuf_dataptr(); hdr->type = TYPE_PROBE; rimeaddr_copy(&hdr->sender, &rimeaddr_node_addr); /* rimeaddr_copy(&hdr->receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));*/ rimeaddr_copy(&hdr->receiver, &rimeaddr_null); packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &rimeaddr_null); { int hdrlen = NETSTACK_FRAMER.create(); if(hdrlen == 0) { /* Failed to send */ return; } } /* Construct the announcements */ adata = (struct announcement_msg *)((char *)hdr + sizeof(struct lpp_hdr)); adata->num = 0; for(a = announcement_list(); a != NULL; a = list_item_next(a)) { adata->data[adata->num].id = a->id; adata->data[adata->num].value = a->value; adata->num++; } packetbuf_set_datalen(sizeof(struct lpp_hdr) + ANNOUNCEMENT_MSG_HEADERLEN + sizeof(struct announcement_data) * adata->num); /* PRINTF("Sending probe\n");*/ /* printf("probe\n");*/ if(NETSTACK_RADIO.channel_clear()) { NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()); } else { off_time_adjustment = random_rand() % (OFF_TIME / 2); } compower_accumulate(&compower_idle_activity); }
/*---------------------------------------------------------------------------*/ static void send_packet(mac_callback_t sent, void *ptr) { int size; /* 3 bytes per packet attribute is required for serialization */ uint8_t buf[PACKETBUF_NUM_ATTRS * 3 + PACKETBUF_SIZE + 3]; int sid; packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &linkaddr_node_addr); /* ack or not ? */ packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1); if(NETSTACK_FRAMER.create_and_secure() < 0) { /* Failed to allocate space for headers */ LOG6LBR_ERROR("br-rdc: send failed, too large header\n"); mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1); } else { /* here we send the data over SLIP to the radio-chip */ size = 0; if(sixlbr_config_slip_serialize_tx_attrs) { size = packetutils_serialize_atts(&buf[3], sizeof(buf) - 3); } if(size < 0 || size + packetbuf_totlen() + 3 > sizeof(buf)) { LOG6LBR_ERROR("br-rdc: send failed, too large header\n"); mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1); } else { sid = setup_callback(sent, ptr); if (sid != -1) { LOG6LBR_PRINTF(PACKET, RADIO_OUT, "write: %d (sid: %d, cb: %d)\n", packetbuf_datalen(), sid, callback_count); LOG6LBR_DUMP_PACKET(RADIO_OUT, packetbuf_dataptr(), packetbuf_datalen()); buf[0] = '!'; buf[1] = 'S'; buf[2] = sid; /* sequence or session number for this packet */ /* Copy packet data */ memcpy(&buf[3 + size], packetbuf_hdrptr(), packetbuf_totlen()); callbacks[sid].buf_len = packetbuf_totlen() + size + 3; memcpy(callbacks[sid].buf, buf, callbacks[sid].buf_len); write_to_slip(buf, callbacks[sid].buf_len); } else { LOG6LBR_INFO("native-rdc queue full\n"); mac_call_sent_callback(sent, ptr, MAC_TX_NOACK, 1); } } } }
/*---------------------------------------------------------------------------*/ static int create(void) { struct nullmac_hdr *hdr; if(packetbuf_hdralloc(sizeof(struct nullmac_hdr))) { hdr = packetbuf_hdrptr(); linkaddr_copy(&(hdr->sender), &linkaddr_node_addr); linkaddr_copy(&(hdr->receiver), packetbuf_addr(PACKETBUF_ADDR_RECEIVER)); return sizeof(struct nullmac_hdr); } PRINTF("PNULLMAC-UT: too large header: %u\n", sizeof(struct nullmac_hdr)); return FRAMER_FAILED; }
/*---------------------------------------------------------------------------*/ static void send_nack(struct rudolph0_conn *c) { struct rudolph0_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph0_hdr)); hdr = packetbuf_hdrptr(); hdr->type = TYPE_NACK; hdr->version = c->current.h.version; hdr->chunk = c->current.h.chunk; PRINTF("Sending nack for %d:%d\n", hdr->version, hdr->chunk); polite_send(&c->nackc, c->send_interval / 2, sizeof(struct rudolph0_hdr)); }
/*---------------------------------------------------------------------------*/ static char plb_send_strobe(rimeaddr_t *dst, int *acked, uint8_t type) { PRINTF("plb_send_strobe [dst: %u.%u] [type: %x]\n",dst->u8[0],dst->u8[1],type); uint8_t strobe[MAX_STROBE_SIZE]; int strobe_len = 0; rtimer_clock_t wt; // Make PLB header packetbuf_clear(); if( (strobe_len = plb_create_header(dst,type)) < 0 ){ return -1; } // Make packet -> strobe strobe_len = strobe_len +1; // assign space for packet type if( strobe_len > (int)sizeof(strobe)) { /* Failed to send */ PRINTF("plb: send failed, too large header\n"); return -1; } memcpy(strobe, packetbuf_hdrptr(), strobe_len); /* Send beacon and wait ack : STROBE_NUM_MAX times */ int strobe_num = 0; radio_on(); while((strobe_num < STROBE_NUM_MAX) && ((*acked) == 0)){ PRINTF("plb_send_strobe : strobe %d\n",strobe_num); #if DEBUG_PACKET print_packet(strobe, strobe_len); #endif if(NETSTACK_RADIO.send(strobe, strobe_len) != RADIO_TX_OK){ return -1; } strobe_num ++; (*acked) = plb_wait_ack(type); if(*acked){ PRINTF("ack! return: %d\n", *acked); } } radio_off(); return 0; }
/*---------------------------------------------------------------------------*/ void queuebuf_to_packetbuf(struct queuebuf *b) { struct queuebuf_ref *r; if(memb_inmemb(&bufmem, b)) { struct queuebuf_data *buframptr = queuebuf_load_to_ram(b); packetbuf_copyfrom(buframptr->data, buframptr->len); packetbuf_attr_copyfrom(buframptr->attrs, buframptr->addrs); } else if(memb_inmemb(&refbufmem, b)) { r = (struct queuebuf_ref *)b; packetbuf_clear(); packetbuf_copyfrom(r->ref, r->len); packetbuf_hdralloc(r->hdrlen); memcpy(packetbuf_hdrptr(), r->hdr, r->hdrlen); } }
/*---------------------------------------------------------------------------*/ int netflood_send(struct netflood_conn *c, uint8_t seqno) { if(packetbuf_hdralloc(sizeof(struct netflood_hdr))) { struct netflood_hdr *hdr = packetbuf_hdrptr(); rimeaddr_copy(&hdr->originator, &rimeaddr_node_addr); rimeaddr_copy(&c->last_originator, &hdr->originator); c->last_originator_seqno = hdr->originator_seqno = seqno; hdr->hops = 0; PRINTF("%d.%d: netflood sending '%s'\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], (char *)packetbuf_dataptr()); return ipolite_send(&c->c, 0, 4); } return 0; }
/*---------------------------------------------------------------------------*/ static void send_nack(struct rudolph1mh_conn *c) { struct rudolph1mh_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr)); hdr = packetbuf_hdrptr(); hdr->type = TYPE_NACK; hdr->s_id = c->s_id; hdr->chunk = c->chunk; PRINTF("%d.%d: Sending nack for %d:%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], hdr->s_id, hdr->chunk); mesh_send(&c->mesh, &c->partner); }
/*---------------------------------------------------------------------------*/ static void send_busy(struct rudolph1mh_conn *c, rimeaddr_t * to) { struct rudolph1mh_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr)); hdr = packetbuf_hdrptr(); hdr->type = TYPE_BUSY; hdr->s_id = 0; hdr->chunk = 0; PRINTF("%d.%d: Sending nack for %d:%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], hdr->s_id, hdr->chunk); mesh_send(&c->mesh, to); }
/*---------------------------------------------------------------------------*/ static void send_nack(struct rudolph1_conn *c) { struct rudolph1_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph1_hdr)); hdr = packetbuf_hdrptr(); hdr->type = TYPE_NACK; hdr->version = c->version; hdr->chunk = c->chunk; PRINTF("%d.%d: Sending nack for %d:%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], hdr->version, hdr->chunk); ipolite_send(&c->ipolite, NACK_TIMEOUT, sizeof(struct rudolph1_hdr)); }
/*---------------------------------------------------------------------------*/ static void send_packet(mac_callback_t sent, void *ptr) { int ret; packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); if(NETSTACK_FRAMER.create() == 0) { /* Failed to allocate space for headers */ PRINTF("nullrdc_framer: send failed, too large header\n"); ret = MAC_TX_ERR_FATAL; } else if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) { ret = MAC_TX_OK; } else { ret = MAC_TX_ERR; } mac_call_sent_callback(sent, ptr, ret, 1); }
/*---------------------------------------------------------------------------*/ static void send_ack(struct rudolph1mh_conn *c) { struct rudolph1mh_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph1mh_hdr)); hdr = packetbuf_hdrptr(); hdr->type = TYPE_ACK; hdr->s_id = c->s_id; hdr->chunk = c->highest_chunk; //The highest chunk received PRINTF("%d.%d: Sending ack for %d:%d to %d.%d\n", rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1], hdr->s_id, hdr->chunk, c->partner.u8[0], c->partner.u8[1]); mesh_send(&c->mesh, &c->partner); }
/*---------------------------------------------------------------------------*/ static void send_nack(struct rudolph2_conn *c) { struct rudolph2_hdr *hdr; packetbuf_clear(); packetbuf_hdralloc(sizeof(struct rudolph2_hdr)); hdr = packetbuf_hdrptr(); hdr->hops_from_base = c->hops_from_base; hdr->type = TYPE_NACK; hdr->version = c->version; hdr->chunk = c->rcv_nxt; PRINTF("%d.%d: Sending nack for %d\n", rimeaddr_node_addr.u8[RIMEADDR_SIZE-2], rimeaddr_node_addr.u8[RIMEADDR_SIZE-1], hdr->chunk); polite_send(&c->c, NACK_TIMEOUT, POLITE_HEADER); }
/*---------------------------------------------------------------------------*/ static void plb_send_ack(uint8_t type){ uint8_t ack[MAX_ACK_SIZE]; int ack_len = 0; //set address from input packet addr_ack.u8[0]=packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[0]; addr_ack.u8[1]=packetbuf_addr(PACKETBUF_ADDR_SENDER)->u8[1]; PRINTF("plb_send_ack [dst: %u.%u] [type: %x]\n", addr_ack.u8[0], addr_ack.u8[1], type); packetbuf_clear(); if ((ack_len = plb_create_header(&addr_ack, type)) < 0) { PRINTF("ERROR: plb_create_header "); return; } ack_len++; //Make ack frame// if (ack_len > (int) sizeof(ack)) { // Failed to send // PRINTF("plb: send failed, too large header\n"); return; } memcpy(ack, packetbuf_hdrptr(), ack_len); // Send beacon and wait ack : STROBE_NUM_MAX times // radio_on(); #if DEBUG_PACKET print_packet(ack, ack_len); #endif if (NETSTACK_RADIO.send(ack, ack_len) != RADIO_TX_OK) { PRINTF("ERROR: plb ack send"); return; } radio_off(); return; }