static EVENT_HANDLER(physical_ready)
{
FRAME f;
size_t len;
int link, checksum;
len = sizeof(FRAME);
CHECK(CNET_read_physical(&link, (char *)&f, &len));
checksum = f.checksum;
f.checksum = 0;
if(CNET_ccitt((unsigned char *)&f, len) != checksum) {
return; // bad checksum, ignore frame
}
switch (f.kind) {
case ACK :
if(f.seq == ackexpected) {
CNET_stop_timer(lasttimer);
ackexpected = 1-ackexpected;
CNET_enable_application(ALLNODES);
}
break;
case DATA :
if(f.seq == frameexpected) {
len = f.len;
CHECK(CNET_write_application((char *)&f.msg, &len));
frameexpected = 1-frameexpected;
}
transmit_frame(NULL, ACK, 0, f.seq);
break;
}
}
static EVENT_HANDLER(physical_ready){
//printf("PR called!\n");
int link;
FRAME f;
size_t length = sizeof(FRAME);
CHECK(CNET_read_physical(&link, (char*)&f, &length));
printf("Packet received from %d, via %d\n", f.payload.source, f.payload.dest);
//DATA LINK LAYER - check if checksum matches
int cs = f.checksum;
f.checksum = 0;
if(CNET_ccitt((unsigned char*)&f, (int)length) != cs){
printf("Bad Checksum - ignoring frame!\n");
return;
}
switch(f.payload.kind){
case RT_DATA : update_table(link, f, length);
break;
case DL_DATA : handle_data(link, f, length);
break;
case DL_ACK : handle_ack(link, f.payload);
break;
default : printf("The world is not enough!\n");
break;
}
//printf("Packet successfully processed!");
}
static void frame_arrived(CnetEvent ev, CnetTimerID timer, CnetData data)
{
if(strcmp(nodeinfo.nodename,"Dehradun")==0 ){
char *ack=(char *)malloc(48*sizeof(char));
int link;
int seq_check;
size_t length=48;
CNET_stop_timer(id);
CHECK(CNET_read_physical(&link, ack, &length));
seq_check = ((int)(ack[0]))-48;
if(seq_check == ((SN+1)%2)){
printf("\n Acknowledgement received ");
flag_sen=1;
count++;
SN= count%2;
}
}
else if(strcmp(nodeinfo.nodename,"KGP")==0 ){
char *frame=(char *)malloc(64*sizeof(char));
char *tobchecked=(char *)calloc(9,sizeof(char));
size_t length=64;
int link;
int i=0;
printf("\n Receiving.....");
CHECK(CNET_read_physical(&link, frame, &length));
for(i=1;i<9;i++){
tobchecked[i]=frame[i];
}
if((strcmp(check,tobchecked))==0){
flag_rec = 1;
if(RN==((int)frame[0])-48){
printf("\nSUCCESSFULLY RECEIVED %u bytes", length);
RN=(RN+1)%2;
flag_sen=1;
}
else{
printf("\n The SN mismatches !");
}
transmit_frame(); //for the acknowledgement
printf("\n The frame is valid");
}
else {
printf("\n The frame is either lost or error");
}
}
}
/**
* physical_ready() event-handler.
*
* It is called when the physical layer is ready. It simply reads from the
* physical layer and passes the message to the link layer.
*/
static EVENT_HANDLER(physical_ready)
{
size_t length;
int link;
length = sizeof(msg);
CHECK(CNET_read_physical(&link, msg, &length));
link_receive(link, msg, length);
}
/****************************************************************************
Read bytes from the data link layer and pass them up to the transport
layer.
****************************************************************************/
void up_to_datalink(CnetEvent ev, CnetTimer timer, CnetData data)
{
int link, length;
length = sizeof(DLL_FRAME);
CHECK(CNET_read_physical(&link, (char *)&frame, &length));
CHECK(up_to_routing(link, frame.packet, length));
}
static void up_to_datalink(CnetEvent ev, CnetTimer timer, CnetData data)
{
DLL_FRAME f;
int link, length;
length = sizeof(DLL_FRAME);
CHECK(CNET_read_physical(&link, (char *)&f, &length));
CHECK(up_to_network(f.packet, length, link));
}
static void datalink_up(CnetEvent ev, CnetTimerID timer, CnetData data)
{
FRAME frame;
int link, checksum;
// READ PHYSICAL LAYER FRAME
size_t frameLength = sizeof(FRAME);
CHECK(CNET_read_physical(&link, (char *)&frame, &frameLength));
// ENSURE CHECKSUM WAS OKAY
checksum = frame.checksum;
frame.checksum = 0;
if (CNET_ccitt((unsigned char *)&frame, (int)frameLength) != checksum)
{
// CHECKSUM IS BAD SO DROP THE PACKET. SENDER WILL TIMEOUT + RESEND
printf("\t\t\t\t\tFRAME RECEIVED\n\t\t\t\t\tBAD CHECKSUM - IGNORE\n");
return;
}
if (frame.kind == DL_DATA)
{
// PRINT FULL INFO OF ALL DATA WITHIN THE FRAME
printf("\n\t\t\t\t\tDATA RECEIVED\n");
printf("\t\t\t\t\tSOURCE:\t%s\n", nodenames[frame.srcNode]);
printf("\t\t\t\t\tDEST:\t%s\n", nodenames[frame.destNode]);
printf("\t\t\t\t\tIN LINK:\t%d\n", link);
printf("\t\t\t\t\tSEQ NO:\t%d\n", frame.seq);
printf("\t\t\t\t\tDATA:\t%s\n", frame.data);
printf("\t\t\t\t\tLENGTH:\t%d\n", frame.len);
// CHECK IF SEQUENCE NUMBER OF FRAME IS THE ONE WE EXPECT
if (frame.seq == frameExpected[link - 1])
{
// ACCEPT IT, THROW FRAME UP TO THE NETWORK LAYER
network_up(frame, link);
}
// CHECK IF FRAME IS A DUPLICATE
// MATHS CHECKS IF SEQ == FRAMEEXPECTED - 1, ACCOUNTING FOR WRAPAROUND
else if (frame.seq == (frameExpected[link - 1] + MAX_SEQ) % (MAX_SEQ + 1))
{
printf("\t\t\t\t\tDUPLICATE FRAME\n");
printf("\t\t\t\t\tEXPECTED: %d\n", frameExpected[ link - 1]);
// DUPLICATE MUST BE BECAUSE ACK LOST, RESEND THE ACK
transmit_ack(link, frame.seq);
}
}
// IF NOT DATA, MUST BE AN ACK FRAME
else
{
// DEAL WITH ACK VIA GO-BACK-N
ack_received(frame, link);
}
}
static EVENT_HANDLER(listening)
{
char buf[1024];
size_t len = sizeof(buf);
int link, from;
double rx_signal, rx_angle;
CHECK(CNET_read_physical(&link, buf, &len));
memcpy(&from, buf, sizeof(int));
CHECK(CNET_wlan_arrival(link, &rx_signal, &rx_angle));
fprintf(stdout,"\t\t%d: received from %d (%.3fdBm @%.3f)\n",
nodeinfo.nodenumber, from, rx_signal, rx_angle);
}
///Event Handler
///Called when this mobile node receives a frame on any of its physical links.
///This frame is propagated to the DLL.
static EVENT_HANDLER(physical_ready)
{
// First we read the frame from the physical layer.
char frame[DLL_MTU];
size_t length = sizeof(frame);
int link;
CHECK(CNET_read_physical(&link, frame, &length));
// Now we forward this information to the data link layer, if it exists.
if (link > nodeinfo.nlinks || dll_states[link] == NULL)
return;
dll_wifi_read(dll_states[link], frame, length);
}
//-----------------------------------------------------------------------------
// read a frame from physical layer
void read_datalink(CnetEvent event, CnetTimerID timer, CnetData data) {
int link;
DL_FRAME frame;
size_t len = PACKET_HEADER_SIZE+DATAGRAM_HEADER_SIZE +
DL_FRAME_HEADER_SIZE + MAX_MESSAGE_SIZE;
CHECK(CNET_read_physical(&link, (char *)&frame, &len));
// compare the checksum
size_t dtg_len = len - DL_FRAME_HEADER_SIZE;
uint16_t checksum = frame.checksum;
uint16_t checksum_to_compare = CNET_ccitt((unsigned char *)&frame.data, dtg_len);
if (checksum_to_compare != checksum) {
return;
}
//read a datagram to network layer
read_network(link, dtg_len, (char*) frame.data);
}
static void frame_arrived(CnetEvent ev, CnetTimer timer, CnetData data)
{
char frame[256];
int link, length, i, ch;
length = sizeof(frame);
CHECK(CNET_read_physical(&link, frame, &length));
printf(" %d bytes arrived on link %d, checksum=%6d : \"",
length, link, checksum_internet((unsigned short *)frame,length));
for(i=0 ; i<length-1 ; ++i) {
ch = frame[i];
if(!(isalnum(ch) || ch == ' '))
ch = '?';
putchar(ch);
}
printf("\"\n\n");
}
/* Function invoked each time a message is ready from physical layer */
static EVENT_HANDLER(physical_ready)
{
// Determine whether the node running the code is the server node.
// If so read message and write to application.
if (nodeinfo.address == 200) {
// Server behaviour.
int link;
char buffer[MAX_MESSAGE_SIZE];
size_t length;
length = sizeof(buffer);
// Read physical layer
CHECK(CNET_read_physical(&link, buffer, &length));
// Write to the application layer.
CNET_write_application(buffer, &length);
printf("Server reads message of length %d\n", length);
}
}
static void physical_ready(CnetEvent ev, CnetTimerID timer, CnetData data)
{
int link = 1;
size_t length;
char packet[MAX_MESSAGE_SIZE];
CHECK(CNET_read_physical(&link, packet, &length));
EthernetHeader *header = (EthernetHeader *) packet;
if (!packet_is_for_this_node(header))
return;
switch (header->type) {
case ETHERTYPE_IP:
ip_accept(packet + ETHERNET_HEADER_SIZE, length - ETHERNET_HEADER_SIZE);
break;
case ETHERTYPE_ARP:
fprintf(stderr, "WHOOPS! Looks like you haven't handled ARP packets yet :)\n");
break;
default:
fprintf(stderr, "Unknown Ethernet packet type: %u\n", header->type);
}
}
static EVENT_HANDLER(receive)
{
WLAN_FRAME frame;
size_t len;
int link;
// READ THE ARRIVING FRAME FROM OUR PHYSICAL LINK
len = sizeof(frame);
CHECK(CNET_read_physical(&link, &frame, &len));
if(verbose) {
double rx_signal;
CHECK(CNET_wlan_arrival(link, &rx_signal, NULL));
fprintf(stdout, "\t%5s: received '%s' @%.3fdBm\n",
nodeinfo.nodename, frame.payload, rx_signal);
}
// IS THIS FRAME FOR ME?
if(frame.header.dest == nodeinfo.nodenumber) {
++stats[1];
if(verbose)
fprintf(stdout, "\t\tfor me!\n");
}
// NO; RETRANSMIT FRAME IF WE'RE CLOSER TO THE DESTINATION THAN THE PREV NODE
else {
CnetPosition dest = positions[frame.header.dest];
double prev = distance(frame.header.prevpos, dest);
double now = distance(positions[nodeinfo.nodenumber],dest);
if(now < prev) { // closer?
frame.header.prevpos = positions[nodeinfo.nodenumber]; // me!
len = sizeof(WLAN_HEADER) + frame.header.length;
CHECK(CNET_write_physical_reliable(link, &frame, &len));
if(verbose)
fprintf(stdout, "\t\tretransmitting\n");
}
}
}
static EVENT_HANDLER(ready_physical)
{
if(nodetype != RECEIVER)
{
ACK_FRAME f;
int link;
size_t length;
length = sizeof(ACK_FRAME);
CHECK(CNET_read_physical(&link, (char*) &f, &length));
uint16_t check = f.check;
f.check = 0;
if(CNET_ccitt((unsigned char*) &f, sizeof(ACK_FRAME)) != check)
return;
if(f.sequence <= 0)
{
// SREJ FRAME
printf("\t\t\t\tSREJ received, sequence=%d\n", -f.sequence);
f.sequence = -f.sequence;
CNET_stop_timer(timer);
trans_frame_state[f.sequence] = ACK_WAIT;
frame_send(&(t_window[f.sequence].message), t_window[f.sequence].length, f.sequence);
}
else
{
// RECVREADY FRAME
printf("\t\t\t\tACK received, sequence=%d\n", f.sequence);
int i;
for(i = (last_ack_recv + 1)%(MAXSEQ + 1); i != f.sequence - 1; i = (i + 1) % (MAXSEQ + 1))
trans_frame_state[i] = ACK_RECEIVED;
last_ack_recv = f.sequence - 1;
trans_frame_state[f.sequence-1] = ACK_RECEIVED;
CNET_stop_timer(timer_wait);
if(packets_sent >= 10000)
{
if(time_end == 0)
time_end = nodeinfo.time_of_day.sec;
}
else
{
packets_sent++;
CNET_enable_application(ALLNODES);
}
}
}
else
{
FRAME_DATA f;
size_t length;
int link;
int checksum;
length = sizeof(FRAME_DATA);
CHECK(CNET_read_physical(&link, (char*) &f, &length));
checksum = f.checksum;
f.checksum = 0;
if(CNET_ccitt((unsigned char*) &f, CHECK_BYTES) != checksum)
{
// bad checksum, ignore frame
printf("\t\t\t\tBAD checksum - frame ignored\n");
ack_send(last_ack_sent + 1, SREJ);
printf("Requesting to send frame %d\n",last_ack_sent+1);
return;
}
recv_frame_status[f.sequence] = RECEIVED;
printf("\t\t\t\tDATA received, sequence=%d\n", f.sequence);
int i;
for(i = (last_ack_sent + 1) % (MAXSEQ + 1); i != f.sequence; i = (i + 1) % (MAXSEQ + 1))
{
if(recv_frame_status[i] != RECEIVED)
break;
}
if(i == f.sequence)
ack_send(f.sequence + 1, RECVREADY);
}
}
