N-sim Emulation and simulation of Wireless Sensor Networks    Home    Project Page    Download    CVS    Installation    Configuration    Plug-ins  Hosted by

/home/brennan/n-sim/Vaike/linux/system-addons/networking/mesh_net.c Go to the documentation of this file. /* * Copyright 2007. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program is free software; you can redistribute * it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; version 2 of * the License. Accordingly, this program is distributed in the hope * it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. */ #define RAW_PACKETS //#define RTSCTS #define _BSD_SOURCE #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/time.h> #include <sys/select.h> #include <netinet/in.h> #include <arpa/inet.h> #include <syslog.h> #include <errno.h> #ifdef RAW_PACKETS #include <netinet/in.h> #include <net/if.h> #include <net/if_arp.h> #include <asm/types.h> #include <linux/filter.h> #include <netinet/ip.h> #include <netinet/udp.h> #include <net/ethernet.h> #endif #include "mesh_net.h" #include "mesh_protocol.h" #include "mesh_discovery.h" #include "mesh_link.h" #include "mesh_neighbor.h" #include "sensor_self.h" /**********************************************************/ /*** stolen verbatim from the ISC DHCP implementation ***/ static struct sock_filter mesh_filter[] = { /* Make sure this is an IP packet... */ BPF_STMT (BPF_LD + BPF_H + BPF_ABS, 12), BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 0, 8), /* Make sure it's a UDP packet... */ BPF_STMT (BPF_LD + BPF_B + BPF_ABS, 23), BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6), /* Make sure this isn't a fragment... */ BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20), BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0), /* Get the IP header length... */ BPF_STMT (BPF_LDX + BPF_B + BPF_MSH, 14), /* Make sure it's to the right port... */ BPF_STMT (BPF_LD + BPF_H + BPF_IND, 16), BPF_JUMP (BPF_JMP + BPF_JEQ + BPF_K, 67, 0, 1), /* patch */ /* If we passed all the tests, ask for the whole packet. */ BPF_STMT(BPF_RET+BPF_K, (u_int)-1), /* Otherwise, drop it. */ BPF_STMT(BPF_RET+BPF_K, 0), }; static u_int32_t checksum(unsigned char *buf, unsigned nbytes, u_int32_t sum) { unsigned i; /* Checksum all the pairs of bytes first... */ for (i = 0; i < (nbytes & ~1U); i += 2) { sum += (u_int16_t) ntohs(*((u_int16_t *)(buf + i))); /* Add carry. */ if (sum > 0xFFFF) sum -= 0xFFFF; } /* If there's a single byte left over, checksum it, too. Network byte order is big-endian, so the remaining byte is the high byte. */ if (i < nbytes) { sum += buf [i] << 8; /* Add carry. */ if (sum > 0xFFFF) sum -= 0xFFFF; } return sum; } /* Finish computing the checksum, and then put it into network byte order. */ static u_int32_t wrapsum(u_int32_t sum) { sum = ~sum & 0xFFFF; return htons(sum); } /**********************************************************/ /*************************************************/ /**** based on the ISC DHCP implementation *****/ static void assemble_ethernet_header(unsigned char *buf, unsigned *bufix, unsigned char *from, unsigned char *to) { struct ether_header eh; if (to != NULL) memcpy (eh.ether_dhost, &to[1], sizeof(eh.ether_dhost)); else memset (eh.ether_dhost, 0xff, sizeof(eh.ether_dhost)); /* bcast MAC */ if (from != NULL) memcpy (eh.ether_shost, &from[1], sizeof(eh.ether_shost)); else memset (eh.ether_shost, 0x00, sizeof(eh.ether_shost)); eh.ether_type = htons(ETHERTYPE_IP); memcpy (&buf[*bufix], &eh, ETHER_HDR_LEN); *bufix += ETHER_HDR_LEN; } static ssize_t decode_ethernet_header(unsigned char *buf, unsigned bufix, unsigned char *from) { struct ether_header eh; memcpy(&eh, buf + bufix, ETHER_HDR_LEN); #ifdef USERLAND_FILTER if (ntohs (eh.ether_type) != ETHERTYPE_IP) return -1; #endif if (from != NULL) { memcpy(&from[1], eh.ether_shost, sizeof(eh.ether_shost)); from[0] = ARPHRD_ETHER; } return ETHER_HDR_LEN; } static void assemble_udp_ip_header (unsigned char *buf, unsigned *bufix, u_int32_t from, u_int32_t to, u_int32_t port, unsigned char *data, unsigned len) { struct ip ip; struct udphdr udp; /* Fill out the IP header */ ip.ip_v = 4; ip.ip_hl = 20; ip.ip_tos = IPTOS_LOWDELAY; ip.ip_len = htons(sizeof(ip) + sizeof(udp) + len); ip.ip_id = 0; ip.ip_off = 0; ip.ip_ttl = IPDEFTTL; ip.ip_p = IPPROTO_UDP; ip.ip_sum = 0; ip.ip_src.s_addr = from; ip.ip_dst.s_addr = to; /* Checksum the IP header... */ ip.ip_sum = wrapsum (checksum ((unsigned char *)&ip, sizeof ip, 0)); /* Copy the ip header into the buffer... */ memcpy (&buf [*bufix], &ip, sizeof ip); *bufix += sizeof ip; /* Fill out the UDP header */ udp.uh_sport = MESH_DISCOVERY_PORT; /* XXX */ udp.uh_dport = port; /* XXX */ udp.uh_ulen = htons(sizeof(udp) + len); memset (&udp.uh_sum, 0, sizeof udp.uh_sum); /* Compute UDP checksums, including the ``pseudo-header'', the UDP header and the data. */ udp.uh_sum = wrapsum (checksum ((unsigned char *)&udp, sizeof udp, checksum (data, len, checksum ((unsigned char *) &ip.ip_src, 2 * sizeof ip.ip_src, IPPROTO_UDP + (u_int32_t) ntohs (udp.uh_ulen))))); /* Copy the udp header into the buffer... */ memcpy (&buf [*bufix], &udp, sizeof udp); *bufix += sizeof udp; } static ssize_t decode_udp_ip_header(unsigned char *buf, unsigned bufix, struct sockaddr_in *from, unsigned buflen, unsigned *rbuflen) { unsigned char *data; struct ip ip; struct udphdr udp; unsigned char *upp, *endbuf; u_int32_t ip_len, ulen, pkt_len; u_int32_t sum, usum; static int ip_packets_seen; static int ip_packets_bad_checksum; static int udp_packets_seen; static int udp_packets_bad_checksum; static int udp_packets_length_checked; static int udp_packets_length_overflow; unsigned len; /* Designate the end of the input buffer for bounds checks. */ endbuf = buf + bufix + buflen; /* Assure there is at least an IP header there. */ if ((buf + bufix + sizeof(ip)) > endbuf) return -1; /* Copy the IP header into a stack aligned structure for inspection. * There may be bits in the IP header that we're not decoding, so we * copy out the bits we grok and skip ahead by ip.ip_hl * 4. */ upp = buf + bufix; memcpy(&ip, upp, sizeof(ip)); ip_len = (*upp & 0x0f) << 2; upp += ip_len; /* Check the IP packet length. */ pkt_len = ntohs(ip.ip_len); if (pkt_len > buflen) return -1; /* Assure after ip_len bytes that there is enough room for a UDP header. */ if ((upp + sizeof(udp)) > endbuf) return -1; /* Copy the UDP header into a stack aligned structure for inspection. */ memcpy(&udp, upp, sizeof(udp)); #ifdef USERLAND_FILTER /* Is it a UDP packet? */ if (ip.ip_p != IPPROTO_UDP) return -1; /* Is it to the port we're serving? */ if (udp.uh_dport != MESH_DISCOVERY_PORT) return -1; #endif /* USERLAND_FILTER */ ulen = ntohs(udp.uh_ulen); if (ulen < sizeof(udp)) return -1; udp_packets_length_checked++; if ((upp + ulen) > endbuf) { udp_packets_length_overflow++; if ((udp_packets_length_checked > 4) && ((udp_packets_length_checked / udp_packets_length_overflow) < 2)) { syslog(LOG_INFO, "%d udp packets in %d too long - dropped", udp_packets_length_overflow, udp_packets_length_checked); udp_packets_length_overflow = 0; udp_packets_length_checked = 0; } return -1; } if ((ulen < sizeof(udp)) || ((upp + ulen) > endbuf)) return -1; /* Check the IP header checksum - it should be zero. */ ++ip_packets_seen; if (wrapsum (checksum (buf + bufix, ip_len, 0))) { ++ip_packets_bad_checksum; if (ip_packets_seen > 4 && (ip_packets_seen / ip_packets_bad_checksum) < 2) { syslog(LOG_INFO, "%d bad IP checksums seen in %d packets", ip_packets_bad_checksum, ip_packets_seen); ip_packets_seen = ip_packets_bad_checksum = 0; } return -1; } /* Copy out the IP source address... */ memcpy(&from->sin_addr, &ip.ip_src, 4); /* Compute UDP checksums, including the ``pseudo-header'', the UDP header and the data. If the UDP checksum field is zero, we're not supposed to do a checksum. */ data = upp + sizeof(udp); len = ulen - sizeof(udp); usum = udp.uh_sum; udp.uh_sum = 0; /* XXX: We have to pass &udp, because we have to zero the checksum * field before calculating the sum...'upp' isn't zeroed. */ sum = wrapsum(checksum((unsigned char *)&udp, sizeof(udp), checksum(data, len, checksum((unsigned char *)&ip.ip_src, 8, IPPROTO_UDP + ulen)))); udp_packets_seen++; if (usum && usum != sum) { udp_packets_bad_checksum++; if (udp_packets_seen > 4 && (udp_packets_seen / udp_packets_bad_checksum) < 2) { syslog(LOG_INFO, "%d bad udp checksums in %d packets", udp_packets_bad_checksum, udp_packets_seen); udp_packets_seen = udp_packets_bad_checksum = 0; } return -1; } /* Copy out the port... */ memcpy (&from -> sin_port, &udp.uh_sport, sizeof udp.uh_sport); /* Save the length of the UDP payload. */ if (rbuflen != NULL) *rbuflen = len; /* Return the index to the UDP payload. */ return ip_len + sizeof udp; } /*************************************************/ int mesh_socket(char *ifname, unsigned int port) { int sd, error, yes = 1; #ifdef RAW_PACKETS struct sock_fprog filter; struct sockaddr my_addr; if ((sd = socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ALL))) < 0) { syslog(LOG_ERR, "socket: %m"); return sd; } //TODO: SO_LINGER = 0 ??? /* setup signal/noise gathering */ if ((error = setsockopt(sd, SOL_IP, IP_PKTINFO, &yes, sizeof(int))) < 0) { syslog(LOG_ERR, "setsockopt (IP_PKTINFO) [%s]: %m", "RF aware routing"); return error; } memset(&my_addr, 0, sizeof(my_addr)); my_addr.sa_family = AF_PACKET; strncpy(my_addr.sa_data, ifname, sizeof (my_addr.sa_data)); if ((error = bind(sd, (struct sockaddr*)&my_addr, sizeof(my_addr))) < 0) { syslog(LOG_ERR, "bind: %m"); return error; } filter.len = sizeof(mesh_filter)/sizeof(struct sock_filter); filter.filter = mesh_filter; mesh_filter[8].k = ntohs((short)port); if ((error = setsockopt(sd, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter))) < 0) { syslog(LOG_ERR, "setsockopt [ATTACH_FILTER] %m"); return error; } #else struct sockaddr_in my_addr; if ((sd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { syslog(LOG_ERR, "socket: %m"); return sd; } my_addr.sin_family = AF_INET; my_addr.sin_port = htons(port); my_addr.sin_addr.s_addr = INADDR_ANY; memset(my_addr.sin_zero, 0, sizeof(my_addr.sin_zero)); if ((error = bind(sd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr))) < 0) { syslog(LOG_ERR, "bind: %m"); return error; } #endif return sd; } #ifdef RTSCTS struct { unsigned int port = 4938; u_int64_t cts_time; } rtscts; enum rc { RTS, CTS}; typedef struct { u_int8_t rtscts; } rtscts_hdr_t; /* thread */ int request_to_send_clear_to_send(protocol_t *proto) { while (1) { rtscts_hdr_t hdr; //listen - not from myself if (hdr.rtscts == RTS) { if (get_current_time() - rtscts.cts_time < THRESHOLD_A) continue; else { rtscts.rts_time = get_current_time(); sendto(CTS, bcast, rtscts.port); } } else if (hdr.rtscts == CTS) { rtscts.cts_time = get_current_time(); // release mutex } } return 0; } #endif ssize_t mesh_sendmsg(char *ifname, char *ifaddr, int sd, void *buf, size_t len, struct sockaddr_in *to) { #ifdef RAW_PACKETS size_t data_len = len + 1536; double hh[16]; unsigned hh_len = 0, ih_len = 0; int alignment; struct sockaddr sa; #else size_t data_len = len; #endif unsigned char data[data_len]; #ifdef RTSCTS u_int64_t hesitate; rtscts_hdr_t hdr; top: // TODO: implement rts/cts for packet sockets if ((hestate = get_current_time() - rtscts.cts_time) < THRESHOLD_A) usleep((unsigned long)hesitate * 1000); else { hdr.rtscts = RTS; sendto(&hdr, sizeof(rtscts_hdr_t), bcast, rtscts.port); } //obtain cts_mutex #endif #ifdef RAW_PACKETS assemble_ethernet_header((unsigned char*)hh, &hh_len, ifaddr, NULL); alignment = hh_len % 4; memcpy(data+alignment, (unsigned char*)hh, hh_len); ih_len = hh_len + alignment; assemble_udp_ip_header(data, &ih_len, 0, to->sin_addr.s_addr, to->sin_port, (unsigned char*)buf, len); memcpy(data+ih_len, buf, len); memset(&sa, 0, sizeof(struct sockaddr)); sa.sa_family = AF_PACKET; strncpy(sa.sa_data, ifname, sizeof(sa.sa_data)); return sendto(sd, data, data_len, 0, &sa, sizeof(struct sockaddr)); #else memcpy(data, buf, data_len); return sendto(sd, data, data_len, 0, (struct sockaddr*)to, sizeof(struct sockaddr)); #endif } ssize_t mesh_recvmsg(int sd, void *buf, size_t len, struct sockaddr_in *from, struct msghdr *msg_header, size_t ctl_msg_size) { struct iovec io_vector; int nbytes; char ctl_msg[ctl_msg_size]; #ifdef RAW_PACKETS int offset = 0; unsigned buf_idx = 0; ssize_t len_rcvd; int reply_size = len + 1536; unsigned char reply[reply_size]; unsigned char hfrom[8]; #else int reply_size = len; void *reply = buf; #endif memset(reply, 0, reply_size); memset(msg_header, 0, sizeof(struct msghdr)); io_vector.iov_base = reply; io_vector.iov_len = reply_size; msg_header->msg_name = from; msg_header->msg_namelen = sizeof(struct sockaddr_in); msg_header->msg_iov = &io_vector; msg_header->msg_iovlen = 1; msg_header->msg_control = ctl_msg; msg_header->msg_controllen = ctl_msg_size; msg_header->msg_flags = 0; if ((nbytes = recvmsg(sd, msg_header, 0)) < 0) return nbytes; #ifdef RAW_PACKETS if ((offset = decode_ethernet_header(reply, buf_idx, hfrom)) < 0) return 0; buf_idx += offset; nbytes -= offset; if ((offset = decode_udp_ip_header(reply, buf_idx, from, nbytes, &len_rcvd)) < 0) return 0; buf_idx += offset; nbytes -= offset; if (nbytes != reply_size) { errno = EMSGSIZE; return -1; } memcpy(buf, &reply[buf_idx], len); #else if (nbytes != reply_size) { errno = EMSGSIZE; return -1; } #endif analyze(self, msg_header); // FIXME: instead use registered packet analysis return nbytes; } int timed_recv(int sd, void *buf, int bytes, struct sockaddr_in *sa, int timeout) { int n, num_bytes; fd_set fds; struct timeval tv; socklen_t addr_len = sizeof(struct sockaddr); FD_ZERO(&fds); FD_SET(sd, &fds); tv.tv_sec = timeout; tv.tv_usec = 0; n = select(sd+1, &fds, NULL, NULL, &tv); if (n == 0) { errno = ETIMEDOUT; return -2; } if (n < 0) return -1; num_bytes = recvfrom(sd, buf, bytes, 0, (struct sockaddr*)sa, &addr_len); #ifdef RAW_PACKETS { unsigned char reply[bytes + 1536]; unsigned buf_idx = 0; int length, offset = 0; unsigned char hfrom[8]; if ((offset = decode_ethernet_header(reply, buf_idx, hfrom)) < 0) return 0; buf_idx += offset; num_bytes -= offset; if ((offset = decode_udp_ip_header(reply, buf_idx, sa, bytes, &length)) < 0) return 0; buf_idx += offset; num_bytes -= offset; if (num_bytes != length) { errno = EMSGSIZE; return -1; } memcpy(buf, &reply[buf_idx], length); } #endif return num_bytes; } int timed_recv_peek(int sd, void *buf, int bytes, struct sockaddr_in *sa, int timeout) { int n, num_bytes; fd_set fds; struct timeval tv; socklen_t addr_len = sizeof(struct sockaddr); FD_ZERO(&fds); FD_SET(sd, &fds); tv.tv_sec = timeout; tv.tv_usec = 0; n = select(sd+1, &fds, NULL, NULL, &tv); if (n == 0) { errno = ETIMEDOUT; return -2; } if (n < 0) return -1; num_bytes = recvfrom(sd, buf, bytes, MSG_PEEK|MSG_WAITALL, (struct sockaddr*)sa, &addr_len); #ifdef RAW_PACKETS { unsigned char reply[bytes + 1536]; unsigned buf_idx = 0; int length, offset = 0; unsigned char hfrom[8]; if ((offset = decode_ethernet_header(reply, buf_idx, hfrom)) < 0) return 0; buf_idx += offset; num_bytes -= offset; if ((offset = decode_udp_ip_header(reply, buf_idx, sa, bytes, &length)) < 0) return 0; buf_idx += offset; num_bytes -= offset; if (num_bytes != length) { errno = EMSGSIZE; return -1; } memcpy(buf, &reply[buf_idx], length); } #endif return num_bytes; } static void pack_mesh_hdr(struct mesh_hdr *mh) { if (mh == NULL) return; mh->protocol_id = htons(mh->protocol_id); mh->seq_num = htonl(mh->seq_num); } static void unpack_mesh_hdr(struct mesh_hdr *mh) { if (mh == NULL) return; mh->protocol_id = ntohs(mh->protocol_id); mh->seq_num = ntohl(mh->seq_num); } ssize_t mesh_raw_send(protocol_t *proto, int sd, void *buf, size_t len, struct sockaddr_in *to) { struct mesh_hdr mh; size_t offset = sizeof(struct mesh_hdr); size_t data_len = len + offset; unsigned char data[data_len]; mh.raw = 1; mh.nack = 0; mh.protocol_id = proto->unique_id; mh.seq_num = 0; pack_mesh_hdr(&mh); memcpy(data, (unsigned char *)&mh, offset); memcpy(data + offset, buf, len); return mesh_sendmsg(proto->sensor->interface, proto->sensor->mac_addr, sd, data, data_len, to); } ssize_t mesh_send(protocol_t *proto, int sd, void *buf, size_t len, struct sockaddr_in *to) { size_t offset = sizeof(struct mesh_hdr); size_t data_len = len + offset; unsigned char data[data_len]; link_entry_t *entry = retrieve_entry(proto, to->sin_addr.s_addr); struct mesh_hdr mh; msg_queue_t *mq; if (entry == NULL) { syslog(LOG_ERR, "no route to %s", inet_ntoa(to->sin_addr)); return -1; } mh.raw = 0; mh.nack = 0; mh.protocol_id = proto->unique_id; mh.seq_num = entry->send_seq_num; pack_mesh_hdr(&mh); memcpy(data, (unsigned char *)&mh, offset); memcpy(data + offset, buf, len); mq = malloc(offset); mq->data = malloc(data_len); memcpy(mq->data, data, data_len); mq->len = data_len; mq->port = to->sin_port; mq->next = NULL; add_msg(entry, mh.seq_num, mq); entry->send_seq_num++; if (entry->send_seq_num > MAX_SEQNUM) entry->send_seq_num = 1; return mesh_sendmsg(proto->sensor->interface, proto->sensor->mac_addr, sd, data, data_len, to); } ssize_t mesh_recv(self_t *self, int sd, void *buf, size_t len, struct sockaddr_in *from) { ssize_t nbytes = 0; size_t offset = sizeof(struct mesh_hdr); size_t data_len = len + offset; unsigned char data[data_len]; seqnum_t diff; link_entry_t *entry; struct mesh_hdr mh; struct msghdr msghdr; protocol_t *proto = NULL; recvr: if ((nbytes = mesh_recvmsg(sd, data, data_len, from, &msghdr, max_ctl_size(self))) < 0) return nbytes; memcpy(&mh, data, offset); unpack_mesh_hdr(&mh); if (mh.raw == 1) return nbytes; proto = protocol_by_id(self, mh.protocol_id); if (mh.nack == 1) { link_entry_t *link = retrieve_entry(proto, from->sin_addr.s_addr); msg_queue_t *msg = retrieve_msg(link, mh.seq_num); from->sin_port = msg->port; mesh_sendmsg(self->interface, self->mac_addr, proto->queue_sd, msg->data, msg->len, from); goto recvr; } if ((entry = retrieve_entry(proto, from->sin_addr.s_addr)) == NULL) { syslog(LOG_ERR, "no route to %s: sequencing unhandled", inet_ntoa(from->sin_addr)); return nbytes; } if (entry->recv_seq_num > MAX_SEQNUM) entry->recv_seq_num = 0; if ((diff = mh.seq_num - entry->recv_seq_num) > 1) { int i; for (i = 0; i < diff; i++) { struct mesh_hdr mhdr; mhdr.raw = 0; mhdr.nack = 1; mhdr.protocol_id = proto->unique_id; mhdr.seq_num = entry->recv_seq_num + i; pack_mesh_hdr(&mhdr); mesh_sendmsg(proto->sensor->interface, proto->sensor->mac_addr, sd, &mhdr, offset, from); } } entry->recv_seq_num += diff; memcpy(buf, data + offset, len); return nbytes; } ssize_t mesh_send_nextdoor(self_t *self, int sd, void *buf, size_t len, double angle, double dist) { neighbor_entry_t *nbr = neighbor_by_position(self, angle, dist); if (nbr == NULL) { errno = -EINVAL; return -1; } return sendto(sd, buf, len, 0, (struct sockaddr*)&nbr->ip, sizeof(struct sockaddr_in)); } ssize_t mesh_recv_nextdoor(self_t *self, int sd, void *buf, size_t len, double *angle, double *dist) { neighbor_entry_t *nbr = NULL; ssize_t nbytes = 0; struct sockaddr_in from; socklen_t addrlen = sizeof(struct sockaddr_in); nbytes = recvfrom(sd, buf, len, 0, (struct sockaddr*)&from, &addrlen); if ((nbr = neighbor_by_ip(self, &from)) == NULL) return -1; *angle = nbr->bearing; *dist = nbr->distance; return nbytes; } /* thread */ int reliable_net(self_t *self) { while (1) { u_int64_t min = UINT64_MAX; protocol_t *proto = self->protocols; while (proto != NULL) { link_entry_t *link = NULL; proto->iterator = NULL; while ((link = iterate_entries(proto)) != NULL) { msg_queue_t *msg; loop: msg = (msg_queue_t*) avl_find_min(&link->send_queue)->element; if (msg->timeout < get_current_time()) { remove_msg(link, msg->id, msg); free(msg); goto loop; } else if (msg->timeout < min) min = msg->timeout; } proto = proto->next; } sleep(min / 1000); } return -1; }

© 2007, Los Alamos National Security, LLC.