void check_serial(void) {
int len;
const unsigned char *packet = read_serial_packet(src, &len);
if (packet) {
packets_read++;
dispatch_packet(packet, len);
free((void *) packet);
}
}
void dhash_unpack_control_packet(evutil_socket_t sock, short what, void *arg)
{
fprintf(stderr, "handle_control_packet\n");
DHash *dhash = (DHash *)arg;
uchar buf[1024];
int n;
if ((n = read(sock, buf, 1024)) < 0)
perror("reading control packet");
dispatch_packet(dhash->control_dispatcher, buf, n, NULL, NULL);
}
int main (int argc, char *argv[])
{
LOG_NOTE("============Start============");
DBHUB->Init();
ACCOUNTHUB->Init();
network_start("../../bin/gate/netcfg.xml");
static char * p = (char *)malloc(MAX_PACKET_SIZE);
// 注册
p_near_register rpack;
rpack.type = 1;
rpack.index = server_index;
get_client_ip_port(rpack.ip,rpack.port);
send_one_packet((char*)&rpack);
LOG_NOTE("============Loaded============");
//
u64 lastTime = 0;
u64 elapse = 0;
while (1)
{
packet * pack = proccess_packet(p);
if (pack) dispatch_packet(pack);
//=====================================
//elapse += TIME->Elapse(lastTime);
//if(elapse > 200)
//{
// p_area_time pTime;
// TIME->SysNow();
// pTime.gid = 1;
// pTime.guid = 2;
// pTime.hour = TIME->SysHour();
// pTime.min = TIME->SysMin();
// pTime.sec = TIME->SysSec();
// pTime.ms = TIME->SysMs();
// send_one_packet((char *)&pTime);
// elapse = 0;
// LOG_INFO("gid:%d. sendTime[%d.%3d]",pTime.gid,pTime.sec,pTime.ms);
//}
sleep(1);
}
//
network_close();
getchar();
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
LOG_NOTE("============Start============");
DBHUB->Init();
network_start("../../bin/ctrl/netcfg.xml");
LOG_NOTE("============Loaded============");
static char * p = (char *)malloc(MAX_PACKET_SIZE);
while (1)
{
packet *pack = proccess_packet(p);
if (pack)
dispatch_packet(pack);
sleep(1);
}
//
network_close();
getchar();
return EXIT_SUCCESS;
}
int dhash_unpack_chord_data(Header *header, DHashPacketArgs *args, Data *msg,
Node *from)
{
fprintf(stderr, "received routing packet\n");
ChordServer *srv = args->chord_args.srv;
DHash *dhash = args->dhash;
int type = dispatcher_get_type(msg->data.data, msg->data.len);
dispatcher_push_arg(dhash->chord_dispatcher, type, srv);
int process_ret;
int ret = dispatch_packet(dhash->chord_dispatcher, msg->data.data,
msg->data.len, from, &process_ret);
dispatcher_pop_arg(dhash->chord_dispatcher, type);
if (!ret || process_ret)
process_data(header, (ChordPacketArgs *)args, msg, from);
return 0;
}
int main(int argc, char **argv)
{
if (argc < 5) {
printf("Usage: %s <tunN> <port> <secret> options...\n"
"\n"
"Options:\n"
" -m <MTU> for the maximum transmission unit\n"
" -a <address/prefix-length> for the private address\n"
" -r <address/prefix-length> for the forwarding route\n"
" -d <address> for the domain name server\n"
" -s <domain> for the search domain\n"
"\n"
"Note that TUN interface needs to be configured properly\n"
"BEFORE running this program. For more information, please\n"
"read the comments in the source code.\n\n", argv[0]);
exit(1);
}
strcpy(_hi_secret, argv[3]);
memcpy(_ll_argv, argv, argc * sizeof(argv[0]));
_ll_argc = argc;
// Wait for a tunnel.
int tunnel;
int dirty = 0;
time_t lastup = time(NULL);
// Get TUN interface.
int interface = get_interface(argv[1]);
do {
int maxfd;
int count;
fd_set readfds;
struct timeval timeout;
dirty = 0;
lastup = time(NULL);
tunnel = get_tunnel(argv[2]);
maxfd = (tunnel > interface? tunnel: interface);
for (; ; ) {
FD_ZERO(&readfds);
FD_SET(tunnel, &readfds);
FD_SET(interface, &readfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
count = select(maxfd + 1, &readfds, NULL, NULL, &timeout);
if (count == -1) {
fprintf(stderr, "select error %s\n", strerror(errno));
exit(-1);
}
if (count > 0) {
int length;
int tunnel_prepare;
int interface_prepare;
struct sockaddr from;
unsigned char packet[2048];
socklen_t fromlen = sizeof(from);
tunnel_prepare = FD_ISSET(tunnel, &readfds);
interface_prepare = FD_ISSET(interface, &readfds);
do {
if (tunnel_prepare) {
length = recvfrom(tunnel, packet, sizeof(packet), MSG_DONTWAIT, &from, &fromlen);
tunnel_prepare = 0;
if (length > 0) {
tunnel_prepare = 1;
if (length > LEN_PADDING + (int)sizeof(struct ipv4_info) && packet[LEN_PADDING]) {
int len = length - LEN_PADDING;
const unsigned char *adj = packet + LEN_PADDING;
if (is_same_network(adj, len)) {
/* route packet to other device. */
dispatch_packet(tunnel, adj, len, &from, fromlen);
} else {
/* dispatch to tun device. */
write(interface, adj, len);
}
lastup = time(NULL);
dirty = 1;
} else if (length > LEN_PADDING) {
int len = length - LEN_PADDING;
const unsigned char *adj = packet + LEN_PADDING;
fprintf(stderr, "recvfrom %d %d %d\n", length, fromlen, from.sa_family);
packet[length] = 0;
handshake_packet(tunnel, adj, len, &from, fromlen);
lastup = time(NULL);
dirty = 1;
}
}
}
if (interface_prepare) {
length = read(interface, packet, sizeof(packet));
interface_prepare = 0;
if (length > (int)sizeof(struct ipv4_info)) {
interface_prepare = 1;
dispatch_packet(tunnel, packet, length, NULL, 0);
}
}
} while (tunnel_prepare || interface_prepare);
continue;
}
if (dirty && lastup + 60 < time(NULL)) {
fprintf(stderr, "idle for long time, try to recreate interface\n");
break;
}
}
close(tunnel);
} while (true);
close(interface);
return 0;
}
/* -----------------------------------------------------------------------
* Background Task
* -----------------------------------------------------------------------
*/
static void
packet_scheduler_timer(void)
{
ws_pktbuf_t *pkt;
uint8_t *buf;
uint8_t phy_len;
mac_fcf_t *fcf, *in_flight_fcf;
uint32_t delta, time;
/*
* Incoming Data
*/
if (ps_state.rx_data_dropped)
{
/* TODO: Keep track of this / do something with this warning */
WS_WARN("received frame has been dropped\n");
ps_state.rx_data_dropped = false;
}
while (ws_ringbuf_has_data(&ps_state.rx_data))
{
/* Load a frame from the ring buffer into a pktbuf */
pkt = ws_pktbuf_create(WS_RADIO_MAX_PACKET_LEN);
if (pkt == NULL)
{
WS_ERROR("failed to allocate memory for received data\n");
break;
}
WS_DEBUG("created packet (pkt=%p)\n", pkt);
buf = ws_pktbuf_get_data(pkt);
ws_ringbuf_pop(&ps_state.rx_data, &phy_len);
ws_ringbuf_read(&ps_state.rx_data, buf, phy_len);
ws_pktbuf_increment_end(pkt, phy_len);
/* Remove the FCS from the end */
ws_pktbuf_remove_from_end(pkt, 2);
WS_DEBUG("received a packet (len=%u, state=%u)\n",
phy_len, mac.state);
fcf = (mac_fcf_t *)ws_pktbuf_get_data(pkt);
/* Packets will get passed to the appropriate upper MAC layer based
* on a number of conditions:
*
* ACK packets get compared to the current in_flight packet.
* If they match, we can clean up the in_flight state, and alert the
* layer above.
*
* mac.state = IDLE
* ignore everything
* mac.state = SCANNING
* beacon frames go to mlme_scan and everything else is ignored
* mac.state = ASSOCIATING
* data is ignored, everything else falls to standard case
*
* fcf.type = BEACON => coordinator
* fcf.type = DATA => MCPS
* fcf.type = MAC => MLME
*/
if (fcf->frame_type == MAC_FRAME_TYPE_ACK)
{
if (ps_state.tx_in_flight != NULL)
{
in_flight_fcf =
(mac_fcf_t *)ws_pktbuf_get_data(ps_state.tx_in_flight);
if (fcf->data[0] == in_flight_fcf->data[0])
{
WS_DEBUG("received ACK for (sqn=%u)\n", fcf->data[0]);
dispatch_status(ps_state.tx_in_flight,
MAC_TX_STATUS_SUCCESS);
clean_tx_state();
}
else
{
WS_DEBUG("ignoring ACK (sqn=%u) frame expected (%u)\n",
fcf->data[0], in_flight_fcf->data[0]);
}
}
else
{
WS_DEBUG("ignoring ACK (sqn=%u) frame\n", fcf->data[0]);
}
WS_DEBUG("dest\n");
ws_pktbuf_destroy(pkt);
}
else
{
switch (mac.state)
{
case MAC_STATE_IDLE:
WS_DEBUG("ignoring (type=%u) in IDLE state\n",
fcf->frame_type);
break;
case MAC_STATE_SCANNING:
if (fcf->frame_type == MAC_FRAME_TYPE_BEACON)
{
mac_mlme_scan_handle_packet(pkt);
}
else
{
WS_DEBUG("ignoring (type=%u) in SCANNING state\n",
fcf->frame_type);
}
break;
case MAC_STATE_ASSOCIATING:
if (fcf->frame_type == MAC_FRAME_TYPE_BEACON ||
fcf->frame_type == MAC_FRAME_TYPE_MAC)
{
mac_mlme_association_handle_packet(pkt);
}
else
{
WS_DEBUG("ignoring (type=%u) in ASSOCIATING state\n",
fcf->frame_type);
}
break;
default:
dispatch_packet(pkt);
break;
}
}
}
/*
* Outgoing Data
*/
switch (ps_state.tx_state)
{
case PACKET_SCHEDULER_TX_STATE_IDLE:
{
packet_scheduler_queue_t *data;
if (!ws_list_is_empty(&ps_state.tx_data))
{
ps_state.tx_state = PACKET_SCHEDULER_TX_STATE_SENDING;
ASSERT(ps_state.tx_in_flight == NULL,
"have data in_flight in IDLE state!\n");
/* Pull the next pktbuf out of the list */
data = ws_list_get_data(ps_state.tx_data.next,
packet_scheduler_queue_t, list);
ws_list_remove(&data->list);
pkt = data->pkt;
FREE(data);
fcf = (mac_fcf_t *)ws_pktbuf_get_data(pkt);
WS_DEBUG("adding frame (type=%u) to TX FIFO\n", fcf->frame_type);
WS_DEBUG("frame: %r\n",
ws_pktbuf_get_data(pkt),
ws_pktbuf_get_len(pkt));
/* Copy the packet to the RF FIFO */
ws_radio_prepare(pkt);
#ifdef GPIO_DEBUG
GPIOPinWrite(DEBUG_GPIO_OTHER_PORT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT);
#endif
if (fcf->ack_req)
{
/* If acknowledgement is requested, we'll prepare the in flight
* state */
ps_state.tx_in_flight = pkt;
ps_state.tx_in_flight_timestamp = ws_radio_timer_get_time();
ps_state.tx_in_flight_retries = 0;
WS_DEBUG("acknowledgement requested\n");
}
else
{
/* Otherwise we'll tidy up the packet */
WS_DEBUG("dest\n");
ws_pktbuf_destroy(pkt);
pkt = NULL;
WS_DEBUG("acknowledgement not requested\n");
}
}
break;
}
case PACKET_SCHEDULER_TX_STATE_SENDING:
/* TODO: This should be a function of the current beacon interval.
* This is roughly calculated for a BO of 5 */
time = ps_state.tx_in_flight_timestamp + 4000;
time &= 0xffffff;
delta = ws_radio_timer_get_time() - time;
if (delta < 0x800000)
{
/* If the packet has not left the radio in a reasonable amount of
* time then we alert the next higher layer with the failure. */
WS_ERROR("failed to transmit packet (%u/%u)\n",
ps_state.tx_in_flight_retries, mac.max_frame_retries);
if (ps_state.tx_in_flight_retries < mac.max_frame_retries)
{
ws_radio_prepare(ps_state.tx_in_flight);
ps_state.tx_in_flight_timestamp = ws_radio_timer_get_time();
ps_state.tx_in_flight_retries++;
ps_state.tx_state = PACKET_SCHEDULER_TX_STATE_SENDING;
#ifdef GPIO_DEBUG
GPIOPinWrite(DEBUG_GPIO_OTHER_PORT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT);
#endif
}
else
{
#ifdef GPIO_DEBUG
GPIOPinWrite(DEBUG_GPIO_OTHER_PORT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT, 0);
#endif
dispatch_status(ps_state.tx_in_flight,
MAC_TX_STATUS_NOT_SENT);
clean_tx_state();
}
}
break;
case PACKET_SCHEDULER_TX_STATE_SENT:
/* TODO: This should be a function of the SIFS PIB attribute.
* This is roughly a slot period, which is too long. */
time = ps_state.tx_in_flight_timestamp + 60;
time &= 0xffffff;
delta = ws_radio_timer_get_time() - time;
if (delta < 0x800000)
{
/* If the ACK message was not received in a reasonable amount of
* time then we should schedule a retransmission */
WS_ERROR("No ACK received (%u/%u)\n",
ps_state.tx_in_flight_retries, mac.max_frame_retries);
if (ps_state.tx_in_flight_retries < mac.max_frame_retries)
{
ws_radio_prepare(ps_state.tx_in_flight);
ps_state.tx_in_flight_timestamp = ws_radio_timer_get_time();
ps_state.tx_in_flight_retries++;
ps_state.tx_state = PACKET_SCHEDULER_TX_STATE_SENDING;
#ifdef GPIO_DEBUG
GPIOPinWrite(DEBUG_GPIO_OTHER_PORT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT,
DEBUG_GPIO_OTHER_TX_IN_FLIGHT);
#endif
}
else
{
WS_ERROR("failed to send within (max_retry=%u) retries\n",
mac.max_frame_retries);
dispatch_status(ps_state.tx_in_flight,
MAC_TX_STATUS_NO_ACK);
clean_tx_state();
}
}
break;
}
}
