/* Relay the message to the next hop using network_send_pkt */
static void
miniroute_relay(network_interrupt_arg_t *intrpt)
{
int i;
int len;
int ttl;
miniroute_header_t routing_hdr = (miniroute_header_t) intrpt->buffer;
network_address_t hop;
len = unpack_unsigned_int(routing_hdr->path_len);
for (i = 0; i < len; ++i) {
unpack_address(routing_hdr->path[i], hop);
if (network_address_same(hostaddr, hop) == 1)
break;
}
if (i + 1 < len) {
i++;
ttl = unpack_unsigned_int(routing_hdr->ttl);
pack_unsigned_int(routing_hdr->ttl, --ttl);
unpack_address(routing_hdr->path[i], hop);
#if MINIROUTE_CACHE_DEBUG == 1
printf("Relaying header\n");
miniroute_print_hdr(routing_hdr);
#endif
network_send_pkt(hop, 0, NULL, intrpt->size, intrpt->buffer);
}
free(intrpt);
}
int transmit_first(int* arg)
{
char buffer[MINIMSG_MAX_MSG_SIZE + 10];
int length = 0;
int i;
network_address_t hostaddr, targetaddr;
miniport_t port;
miniport_t dest;
struct mini_header hdr;
AbortOnCondition(network_translate_hostname(hostname, targetaddr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(0);
dest = miniport_create_bound(targetaddr, 1);
/* Form correct header */
network_get_my_address(hostaddr);
hdr.protocol = PROTOCOL_MINIDATAGRAM;
pack_address(hdr.source_address, hostaddr);
pack_unsigned_short(hdr.source_port, port->num);
pack_address(hdr.destination_address, dest->bound.addr);
pack_unsigned_short(hdr.destination_port, dest->bound.remote);
/* Send packages with short but correct header and zero data */
printf("Sending packages with short headers.\n");
sprintf(buffer, "Receiving packages with short headers.\n");
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
for (i = 0; i < MINIMSG_HDRSIZE; i++)
network_send_pkt(targetaddr, i, (char*)&hdr, 0, buffer);
/* Send packages to wrong ports */
printf("Sending packages to wrong destination ports.\n");
sprintf(buffer, "Receiving packages with wrong destination ports.\n");
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
sprintf(buffer, "This message is sent to a wrong port.\n");
length = strlen(buffer) + 1;
minimsg_send(port, miniport_create_bound(targetaddr, 0),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_UNBOUNDED),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_UNBOUNDED + 1),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MIN_BOUNDED),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_BOUNDED),
buffer, length);
printf("Send-first finished.\n");
return 0;
}
/* minisocket_send_ctrl creates an ctrl packet of type type and with
* fields taken from the sock parameter.
* This ack packet is sent over the network.
* If there is an underlying network failure, error is updated
* but the pkt is not resent.
* The address of pkt is given as the data buffer,
* but no data from pkt is written since the data_len is 0.
*/
void minisocket_send_ctrl(char type, minisocket_t sock, minisocket_error* error) {
struct mini_header_reliable pkt;
pkt.protocol = PROTOCOL_MINISTREAM;
pack_address(pkt.source_address, my_addr);
pack_unsigned_short(pkt.source_port, sock->src_port);
pack_address(pkt.destination_address, sock->dst_addr);
pack_unsigned_short(pkt.destination_port, sock->dst_port);
pkt.message_type = type;
pack_unsigned_int(pkt.seq_number, sock->curr_seq);
pack_unsigned_int(pkt.ack_number, sock->curr_ack);
if (network_send_pkt(sock->dst_addr, sizeof(pkt),
(char*)&pkt, 0, (char*)&pkt) == -1) {
*error = SOCKET_SENDERROR;
}
}
/* Sends a message through a locally bound port (the bound port already has an associated
* receiver address so it is sufficient to just supply the bound port number). In order
* for the remote system to correctly create a bound port for replies back to the sending
* system, it needs to know the sender's listening port (specified by local_unbound_port).
* The msg parameter is a pointer to a data payload that the user wishes to send and does not
* include a network header; your implementation of minimsg_send must construct the header
* before calling miniroute_send_pkt(). The return value of this function is the number of
* data payload bytes sent not inclusive of the header.
*/
int minimsg_send(miniport_t local_unbound_port, miniport_t local_bound_port, minimsg_t msg, int len) {
network_address_t dest, my_address;
mini_header_t hdr;
// semaphore_P(msgmutex);
// Check for valid arguments
if (local_unbound_port == NULL) {
fprintf(stderr, "ERROR: minimsg_send() passed a NULL local_unbound_port miniport argument\n");
semaphore_V(msgmutex);
return -1;
}
if (local_bound_port == NULL) {
fprintf(stderr, "ERROR: minimsg_send() passed a NULL local_bound_port miniport argument\n");
semaphore_V(msgmutex);
return -1;
}
// Allocate new header for packet
hdr = malloc(sizeof(struct mini_header));
if (hdr == NULL) { // Could not allocate header
fprintf(stderr, "ERROR: minimsg_send() failed to malloc new mini_header\n");
semaphore_V(msgmutex);
return -1;
}
// Assemble packet header
hdr->protocol = PROTOCOL_MINIDATAGRAM; // Protocol
network_get_my_address(my_address);
pack_address(hdr->source_address, my_address); // Source address
pack_unsigned_short(hdr->source_port, local_bound_port->port_num); // Source port
network_address_copy(local_bound_port->u.bound.remote_address, dest);
pack_address(hdr->destination_address, dest); // Destination address
pack_unsigned_short(hdr->destination_port, local_bound_port->u.bound.remote_unbound_port); // Destination port
// Call miniroute_send_pkt() from network.hdr
if (network_send_pkt(dest, sizeof(struct mini_header), (char*) hdr, len, msg) < 0) { // REMOVE THIS LINE
// if (miniroute_send_pkt(dest, sizeof(struct mini_header), (char*) hdr, len, msg) < 0) {
fprintf(stderr, "ERROR: minimsg_send() failed to successfully execute miniroute_send_pkt()\n");
semaphore_V(msgmutex);
return -1;
}
// semaphore_V(msgmutex);
return 0;
}
/* Process a route discovery packet */
static void
miniroute_process_discovery(network_interrupt_arg_t *intrpt)
{
miniroute_header_t hdr = (miniroute_header_t) intrpt->buffer;
network_address_t orig;
network_address_t dest;
int id;
int len;
int ttl;
miniroute_path_t path;
miniroute_disc_hist_t disc;
#if MINIROUTE_CACHE_DEBUG == 1
printf("Received discovery packet with header: \n");
miniroute_print_hdr(hdr);
#endif
id = unpack_unsigned_int(hdr->id);
len = unpack_unsigned_int(hdr->path_len);
pack_unsigned_int(hdr->path_len, ++len);
pack_address(hdr->path[len - 1], hostaddr);
unpack_address(hdr->path[0], orig);
unpack_address(hdr->destination, dest);
if (network_address_same(dest, hostaddr) != 1) {
miniroute_cache_get_by_addr(disc_cache, orig, (void**)&disc);
if (!(NULL != disc && disc->id == id)) {
disc = miniroute_dischist_from_hdr(hdr);
miniroute_cache_put_item(disc_cache, disc);
ttl = unpack_unsigned_int(hdr->ttl);
pack_unsigned_int(hdr->ttl, --ttl);
network_bcast_pkt(0, NULL, intrpt->size, intrpt->buffer);
}
} else {
path = miniroute_path_from_hdr(hdr);
miniroute_cache_put_item(route_cache, path);
miniroute_pack_reply_hdr(hdr, id, path);
#if MINIROUTE_CACHE_DEBUG == 1
printf("Processed discovery packet, replying with header: \n");
miniroute_print_hdr(hdr);
#endif
network_send_pkt(path->hop[1], MINIROUTE_HDRSIZE, (char*)hdr, 0, NULL);
}
free(intrpt);
}
static void send_control_message(int msg_type, unsigned int dest_port,
network_address_t dest_addr, unsigned int src_port,
unsigned int seq, unsigned int ack, minisocket_error *error)
{
mini_header_reliable_t *header = create_control_header(msg_type, dest_port,
dest_addr, src_port,
seq, ack);
if (!header) {
*error = SOCKET_OUTOFMEMORY;
return;
}
if (network_send_pkt(dest_addr, sizeof(mini_header_reliable_t), (char *) header, 0, NULL) == -1)
{
*error = SOCKET_SENDERROR;
return;
}
}
/* sends a miniroute packet, automatically discovering the path if necessary.
* See description in the .h file.
*/
int
miniroute_send_pkt(network_address_t dest_address, int hdr_len, char* hdr,
int data_len, char* data)
{
int total_len = hdr_len + data_len;
int sent_len = 0;
struct routing_header routing_hdr;
char *total_data = malloc(total_len);
miniroute_path_t path = NULL;
/* Find route if it is not in cache */
semaphore_P(discovery_mutex);
miniroute_cache_get_by_addr(route_cache, dest_address, (void**)&path);
if (NULL == path || path->exp_time < ticks) {
#if MINIROUTE_CACHE_DEBUG == 1
printf("Address not found, discovering path.\n");
#endif
path = miniroute_discover_path(dest_address);
}
semaphore_V(discovery_mutex);
if (NULL != path && NULL != (total_data = malloc(total_len))) {
/* Pack data and miniroute header */
memcpy(total_data, hdr, hdr_len);
memcpy(total_data + hdr_len, data, data_len);
miniroute_pack_data_hdr(&routing_hdr, path);
sent_len = network_send_pkt(path->hop[1], MINIROUTE_HDRSIZE,
(char*)&routing_hdr, total_len, total_data);
}
#if MINIROUTE_DEBUG == 1
printf("Network packet sent.\n");
#endif
#if MINIROUTE_CACHE_DEBUG == 1
printf("Sending data with header: \n");
miniroute_print_hdr(&routing_hdr);
#endif
if (sent_len < hdr_len)
return -1;
else
return sent_len - hdr_len;
}
/* Used when we want to retransmit a given packet a certain number of times while a desired response has not been received
(relies on network_handler to get said response). Return -1 on Failure, 0 if Timed out, 1 if Received packet. */
int retransmit_packet(minisocket_t socket, char* hdr, int data_len, char* data, minisocket_error *error) {
int send_attempts, timeout, received_next_packet;
int exec = 0;
send_attempts = 0;
timeout = INITIAL_TIMEOUT;
received_next_packet = 0;
// "Reset" alarm field
socket->alarm = NULL;
while (send_attempts < MAX_SEND_ATTEMPTS && !received_next_packet) {
if (network_send_pkt(socket->dest_address, sizeof(struct mini_header_reliable), hdr, data_len, data) < 0) {
fprintf(stderr, "ERROR: retransmit_packet() failed to successfully execute network_send_pkt()\n");
*error = SOCKET_SENDERROR;
// semaphore_V(skt_mutex);
return -1; // Failure
}
fprintf(stderr, "DEBUG: Sent %i with (seq = %i, ack = %i) attempt %i\n", ((mini_header_reliable_t) hdr)->message_type, unpack_unsigned_int(((mini_header_reliable_t) hdr)->seq_number), unpack_unsigned_int(((mini_header_reliable_t) hdr)->ack_number), send_attempts + 1);
// Block here until timeout expires (and alarm is thus deregistered) or packet is received, deregistering the pending alarm
// CHECK: need to enforce mutual exclusion here?
exec = wait_for_arrival_or_timeout(socket->datagrams_ready, &(socket->alarm), timeout); //CHECK: Is this the CORRECT semaphore to block on?
fprintf(stderr, "executed: %i\n", exec);
// if (((alarm_t) socket->alarm)->executed) { // Timeout has been reached without ACK
if (exec) {
timeout *= 2;
send_attempts++;
} else { // ACK (or equivalent received)
received_next_packet = 1;
socket->alarm = NULL; // No active retransmission alarm
}
}
return received_next_packet;
}
/* Sends a message through a locally bound port (the bound port already has an associated
* receiver address so it is sufficient to just supply the bound port number). In order
* for the remote system to correctly create a bound port for replies back to the sending
* system, it needs to know the sender's listening port (specified by local_unbound_port).
* The msg parameter is a pointer to a data payload that the user wishes to send and does not
* include a network header; your implementation of minimsg_send must construct the header
* before calling network_send_pkt(). The return value of this function is the number of
* data payload bytes sent not inclusive of the header. Returns -1 on error.
* Fails if msg is too long.
*/
int
minimsg_send(miniport_t local_unbound_port, miniport_t local_bound_port, minimsg_t msg, int len) {
struct mini_header hdr;
network_address_t dst_addr;
if (len > MINIMSG_MAX_MSG_SIZE) {
return -1;
}
if (local_unbound_port == NULL ||
local_unbound_port->p_type != UNBOUND_PORT ||
local_unbound_port->p_num >= BOUND_PORT_START ||
miniport_array[local_unbound_port->p_num] != local_unbound_port) {
return -1;
}
if (local_bound_port == NULL ||
local_bound_port->p_type != BOUND_PORT ||
local_bound_port->p_num < BOUND_PORT_START ||
miniport_array[local_bound_port->p_num] != local_bound_port) {
return -1;
}
network_address_copy(local_bound_port->u.bound.dest_addr, dst_addr);
hdr.protocol = PROTOCOL_MINIDATAGRAM;
pack_address(hdr.source_address, my_addr);
pack_unsigned_short(hdr.source_port, local_unbound_port->p_num);
pack_address(hdr.destination_address, local_bound_port->u.bound.dest_addr);
pack_unsigned_short(hdr.destination_port, local_bound_port->u.bound.dest_num);
if (network_send_pkt(dst_addr, sizeof(hdr), (char*)&hdr, len, msg)) {
return -1;
}
return len;
}
int
minimsg_send(miniport_t* local_unbound_port, miniport_t* local_bound_port, minimsg_t* msg, int len)
{
assert(g_boundPortCounter >= 0); //sanity check to ensure minimsg_initialize() has been called first
//validate input
if (local_unbound_port == NULL || local_bound_port == NULL || msg == NULL || len < 0 || len > MINIMSG_MAX_MSG_SIZE) return -1;
//generate the header
mini_header_t header;
header.protocol = PROTOCOL_MINIDATAGRAM; //set protocol type
network_address_t my_address;
network_get_my_address(my_address);
pack_address(header.source_address, my_address);
pack_unsigned_short(header.source_port, local_unbound_port->port_number);
pack_address(header.destination_address, local_bound_port->bound_port.remote_addr);
pack_unsigned_short(header.destination_port, local_bound_port->bound_port.remote_unbound_port);
//send message now
int sentBytes = network_send_pkt(local_bound_port->bound_port.remote_addr, sizeof(header), (char*)&header, len, msg);
if (sentBytes == -1) return -1; //we failed to send our message
else return sentBytes - sizeof(header); //else return size of our message not inclusive of header
}
void minisocket_close(minisocket_t *socket) {
if (socket == NULL || mini_socket_data[socket->local_port_number] == NULL || socket->state == CLOSED) {
return; // no cleanup necessary
}
fprintf(stderr, "Closing time \n");
mini_header_reliable_t header;
minisocket_create_reliable_header((mini_header_reliable_t *) &header, socket, socket->remote_port_number, socket->remote_address, MSG_FIN);
int send_success = 0;
int timeout = START_TIMEOUT / 2;
for (int i = 0; i < MAX_FAILURES; i++) {
if (socket->state == CLOSED) {
return; //received a MSG_FIN message in network_handler, so stop re-tries
}
timeout = timeout * 2;
network_send_pkt(socket->remote_address, sizeof(mini_header_reliable_t), (char *) &header, 0, empty_message);
alarm_id timeout_alarm_id = register_alarm(timeout, handshake_timeout_handler, (void *) socket->ack_ready);
int alarm_fired = 0;
//keep looking through received packets until either the alarm fires or it finds the correct packet
while (!send_success && !alarm_fired) {
semaphore_P(socket->ack_ready);
//alarm has fired, since there are no packets to be received
if (queue_length(socket->acknowledgements) == 0) {
printf("CLOSE queue length: %d\n", queue_length(socket->acknowledgements));
alarm_fired = 1; //goes to next iteration of for loop
}
//There is a packet (alarm hasnt fired yet)
else {
network_interrupt_arg_t* interrupt_message = NULL;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
queue_dequeue(socket->acknowledgements, (void **) &interrupt_message);
set_interrupt_level(old_level);
// verify non null message
if (interrupt_message != NULL) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
//already checked port and address in network_handler
if (received_header->message_type == MSG_ACK) {
deregister_alarm(timeout_alarm_id); //only deregister alarm when the right packet is found
send_success = 1;
free(interrupt_message);
break;
}
else {
free(interrupt_message);
}
}
}
}
if (send_success) {
break;
}
}
printf("out of CLOSE\n");
//sender considers the connection closed, even if MSG_ACK not received
if (socket->state != CLOSED) {
printf("calling DESTROY from CLOSE\n");
minisocket_destroy(socket);
}
}
/* Transmit a packet and handle retransmissions */
int transmit_packet(minisocket_t socket, network_address_t dst_addr, int dst_port,
short incr_seq, char message_type, int data_len, char* data,
minisocket_error* error)
{
mini_header_reliable_t header;
int alarm_id;
short success = 0;
network_address_t my_addr;
int send_ret;
interrupt_level_t prev_level;
network_get_my_address(my_addr);
// Return if the socket is invalid
if (socket == NULL)
{
*error = SOCKET_INVALIDPARAMS;
return -1;
}
// Don't allow new packets to be transmitted if the port's closing
if (socket->status == TCP_PORT_CLOSING)
{
*error = SOCKET_SENDERROR;
return -1;
}
// Increment the seq# if needed
if (incr_seq == 1)
{
socket->seq_num++;
}
// Create the header
header = create_reliable_header(my_addr, socket->port_number, dst_addr,
dst_port, message_type, socket->seq_num,
socket->ack_num);
// Can retransmit for each timeout up to 6400 (100 + 200 + 400 + ... + 6400 = 12.7s)
socket->timeout = 100;
while (socket->timeout <= 6400)
{
// send the packet
send_ret = network_send_pkt(dst_addr, sizeof(struct mini_header_reliable),
(char*) header, data_len, (char*) data);
// Check if there was an error sending
if (send_ret == -1)
{
// Could've been a fluke, let it keep going
continue;
}
// Seq # is count of retransmissable packets... if dont increment it,
// then this isn't retransmissable, so end
if (incr_seq == 0)
{
free(header);
return 0;
}
// Set an alarm to wake us up after timeout
alarm_id = register_alarm(socket->timeout, &wake_up_sem, socket);
// Specify the type of packet we're waiting for
if (message_type == MSG_SYN)
{
socket->waiting = TCP_PORT_WAITING_SYNACK;
}
else
{
socket->waiting = TCP_PORT_WAITING_ACK;
}
// Sleep on semaphore
prev_level = set_interrupt_level(DISABLED);
semaphore_P(socket->wait_for_ack_sem);
set_interrupt_level(prev_level);
// Check if we got the packet when we've awoken
if (socket->waiting == TCP_PORT_WAITING_NONE)
{
// Yes, we did - delete the alarm and break out of the loop
deregister_alarm(alarm_id);
success = 1;
break;
}
else
{
if (socket->status == TCP_PORT_COULDNT_CONNECT)
{
// This means the client sent a FIN while we were trying to connect
success = 0;
deregister_alarm(alarm_id);
break;
}
// No, we didn't - double the timeout and repeat if we can
socket->timeout *= 2;
}
}
// So the IH knows the sequence is done (see comment block in network_common:170)
// There is a small chance that the code around network_common:170 won't catch
// this in time and won't send one last packet - that is okay, as Prof. Sirer
// mentioned sending that packet isn't even necessary in the first place.
socket->timeout = 100;
// Free the header as it's no longer needed
free(header);
// If we weren't successful...
if (success == 0)
{
// Decrement the seq# if we incremented it earlier
if (incr_seq == 1)
{
socket->seq_num--;
}
// Reset the socket's waiting status
socket->waiting = TCP_PORT_WAITING_NONE;
// Set the error & return
*error = SOCKET_NOSERVER;
return -1;
}
return 0;
}
void network_handler(network_interrupt_arg_t* packet) {
interrupt_level_t old_level = set_interrupt_level(DISABLED);
//strip relevant packet header information
mini_header_t* header = (mini_header_t *) packet->buffer;
unsigned short dest_port = unpack_unsigned_short(header->destination_port);
char packet_protocol = header->protocol;
if (packet_protocol == PROTOCOL_MINIDATAGRAM) {
//appends entire packet (including header) to the relevant miniport queue
miniport_t* mini = minimsg_get_port(dest_port);
if (mini == NULL) {
set_interrupt_level(old_level);
free(packet);
return; //unallocated mini_port within minimsg, so drop packet!
}
//wake up possible waiting threads (or keep track of enqueued packets)
queue_append(mini->port_data.incoming_data, packet);
semaphore_V(mini->port_data.datagrams_ready);
set_interrupt_level(old_level);
}
else {
//printf("handling TCP packet\n\n");
mini_header_reliable_t* received_header = (mini_header_reliable_t *) packet->buffer;
minisocket_t* socket = minisocket_get_socket(dest_port);
if (socket == NULL) {
printf("no socket found type: %u\n", received_header->message_type);
free(packet);
set_interrupt_level(old_level);
return;
}
//check packet size
if (packet->size < sizeof(mini_header_reliable_t)) {
free(packet);
return;
}
//sending header data
network_address_t send_address;
unpack_address(received_header->source_address, send_address);
mini_header_reliable_t send_header;
unsigned short source_port = unpack_unsigned_short(received_header->source_port);
minisocket_create_reliable_header((mini_header_reliable_t *) &send_header, socket, source_port, send_address, MSG_ACK);
if (socket->state == CLOSED && received_header->message_type == MSG_FIN) {
printf("ACKing FIN packet\n");
//closed socket that hasn't been re-allocated, send back MSG_ACK
send_header.message_type = MSG_ACK;
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
free(packet);
set_interrupt_level(old_level);
return;
}
if (socket->state == CONNECTING || socket->state == LISTENING) {
//currently trying to establish a connection to socket
queue_append(socket->acknowledgements, packet);
semaphore_V(socket->ack_ready);
set_interrupt_level(old_level);
return;
}
//check that this packet source information matches expected socket connection
if (socket->state == CONNECTED && socket->remote_port_number == source_port && network_compare_network_addresses(socket->remote_address, send_address) != 0) {
if (packet->size == sizeof(mini_header_reliable_t) && received_header->message_type == MSG_ACK) {
//printf("got empty ACK packet with ack: %u\n", unpack_unsigned_int(received_header->ack_number));
// received ack return message for pending sent message
queue_append(socket->acknowledgements, packet);
semaphore_V(socket->ack_ready);
set_interrupt_level(old_level);
return;
}
if (packet->size == sizeof(mini_header_reliable_t) && received_header->message_type == MSG_SYNACK) {
send_header.message_type = MSG_ACK;
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
free(packet);
return;
}
if (received_header->message_type == MSG_FIN) {
printf("received messsage FIN\n");
// received termination message for currently connected socket
// send back MSG_ACK to closer
send_header.message_type = MSG_ACK;
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
//mark socket as closed, so no further calls can be made to send() or receive()
socket->state = CLOSED;
printf("REGISTERING ALARM\n");
//sleep for 15s before destroying the socket
register_alarm(15000, minisocket_destroy, (void *) socket);
set_interrupt_level(old_level);
return;
}
//check sequence number
unsigned int seq_number = unpack_unsigned_int(received_header->seq_number);
if (seq_number < socket->ack) {
//printf("already seen this!\n");
//have seen this packet before, send an ACK to client
send_header.message_type = MSG_ACK;
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
//free(packet);
set_interrupt_level(old_level);
return;
}
else if (seq_number > socket->ack) {
//printf("don't want packet yet!\n");
//want to wait for earlier sequential packet
free(packet);
set_interrupt_level(old_level);
return;
}
else if (seq_number == socket->ack && received_header->message_type == MSG_ACK && packet->size > sizeof(mini_header_reliable_t)) { //else seq_number == socket->ack
// append data packet and increment ack number
queue_append(socket->incoming_data, packet);
semaphore_V(socket->datagrams_ready);
send_header.message_type = MSG_ACK;
unsigned int new_ack = seq_number + packet->size - sizeof(mini_header_reliable_t);
pack_unsigned_int(send_header.ack_number, new_ack);
socket->ack = new_ack;
//printf("sending ack %u\n", socket->ack);
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
set_interrupt_level(old_level);
}
}
else {
//send back a MSG_FIN to request that this client stop sending messages
network_send_pkt(send_address, sizeof(mini_header_reliable_t), (char *) &send_header, 0, NULL);
set_interrupt_level(old_level);
}
}
}
minisocket_t* minisocket_server_create(int port, minisocket_error *error) {
//Check socket number first
if (valid_server_port(port) == 0) {
*error = SOCKET_INVALIDPARAMS;
return NULL;
}
//check if socket is already in use
if (mini_socket_data[port] != NULL) {
*error = SOCKET_PORTINUSE;
return NULL;
}
minisocket_t* socket = (minisocket_t *) malloc(sizeof(minisocket_t));
if (socket == NULL) {
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
socket->state = LISTENING;
socket->socket_type = SERVER_TYPE;
socket->local_port_number = port;
network_address_t my_address;
network_get_my_address(my_address);
network_address_copy(my_address, socket->local_address);
socket->datagrams_ready = semaphore_create();
semaphore_initialize(socket->datagrams_ready, 0);
socket->ack_ready = semaphore_create();
semaphore_initialize(socket->ack_ready, 0);
socket->incoming_data = queue_new();
socket->acknowledgements = queue_new();
socket->seq = 0;
socket->ack = 0;
socket->next_read = 0;
//add socket to global array
mini_socket_data[socket->local_port_number] = socket;
char connection_established = 0;
mini_header_reliable_t header;
minisocket_create_reliable_header((mini_header_reliable_t *) &header, socket, socket->remote_port_number, socket->remote_address, MSG_SYNACK);
network_address_t dest;
pack_unsigned_int(header.seq_number, socket->seq);
pack_unsigned_int(header.ack_number, socket->ack);
//loop until a full connection is established
while (connection_established == 0) {
//sleep until initial MSG_SYN arrives from client
char message_received = 0;
while (message_received == 0) {
//Waits until it receives a packet
semaphore_P(socket->ack_ready);
interrupt_level_t old_level = set_interrupt_level(DISABLED);
network_interrupt_arg_t* interrupt_message = NULL;
queue_dequeue(socket->acknowledgements, (void **) &interrupt_message);
set_interrupt_level(old_level);
//TODO: check more contents of message? change seq and ack values in response??}
if (interrupt_message != NULL ) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
unpack_address(received_header->source_address, dest);
pack_address(header.destination_address, dest);
pack_unsigned_short(header.destination_port, unpack_unsigned_short(received_header->source_port));
if (valid_client_port(unpack_unsigned_short(received_header->source_port)) == 1) { //check valid port number
if (received_header->message_type != MSG_SYN) { //check valid message type
header.message_type = MSG_FIN;
network_send_pkt(dest, sizeof(mini_header_reliable_t), (char *) &header, 0, empty_message);
free(interrupt_message);
}
else {
//set remote port values
printf("server got the SYN message\n");
socket->remote_port_number = unpack_unsigned_short(received_header->source_port);
network_address_copy(dest, socket->remote_address);
socket->seq = unpack_unsigned_int(received_header->seq_number);
message_received = 1; //will break loop
free(interrupt_message);
socket->state = CONNECTING;
break;
}
}
}
}
//reset loop value for return
message_received = 0;
//otherwise the message was the correct type and format
int timeout = START_TIMEOUT / 2; //this way first timeout will be at START_TIMEOUT
for (int i = 0; i < MAX_FAILURES; i++) {
printf("sending MSG_SYNACK in server, i: %d\n", i);
timeout = timeout * 2;
header.message_type = MSG_SYNACK;
network_send_pkt(dest, sizeof(mini_header_reliable_t), (char *) &header, 0, empty_message);
alarm_id timeout_alarm_id = register_alarm(timeout, handshake_timeout_handler, (void *) socket->ack_ready);
int alarm_fired = 0;
//keep looking through received packets until either the alarm fires or it finds the correct packet
while (!connection_established && !alarm_fired) {
semaphore_P(socket->ack_ready);
//alarm has fired, since there are no packets to be received
if (queue_length(socket->acknowledgements) == 0) {
alarm_fired = 1; //goes to next iteration of for loop
}
//There is a packet (alarm hasnt fired yet)
else {
network_interrupt_arg_t* interrupt_message = NULL;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
queue_dequeue(socket->acknowledgements, (void **) &interrupt_message);
set_interrupt_level(old_level);
// verify non null message
if (interrupt_message != NULL) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
network_address_t temp_address;
unpack_address(received_header->source_address, temp_address);
if (socket->remote_port_number == unpack_unsigned_short(received_header->source_port) &&
network_compare_network_addresses(socket->remote_address, temp_address) != 0 &&
received_header->message_type == MSG_ACK) {
//same address, same ports, right message
deregister_alarm(timeout_alarm_id); //only deregister alarm when the right packet is found
connection_established = 1;
//queue_prepend(socket->acknowledgements, interrupt_message); //ack works as well when there is data
break;
}
else {
free(interrupt_message);
}
}
}
}
if (connection_established) {
//correct response has been found, get out of this timeout loop!
break;
}
}
//if timeout occurs, will loop back to initial waiting phase for MSG_SYN from client
}
printf("leaving server create\n");
//update server socket values with client connection
socket->state = CONNECTED;
assert(socket != NULL);
return socket;
}
void network_handler(network_interrupt_arg_t* arg)
{
// Used to extract the network address out of the interrupt argument
//network_address_t addr;
// The source port number - this is really the remote unbound port number
int src_port_number;
// The port number the packet was sent to
int dst_port_number;
// Used to store the header data for UDP/minimsgs
mini_header_t header;
// This is used to extract the sender's address from the header
network_address_t src_addr;
// This is used to extract the destination (our) address from the header
network_address_t dst_addr;
// Disable interrupts...
interrupt_level_t prev_level = set_interrupt_level(DISABLED);
// This is used to check our own address for sanity checks
network_address_t my_addr;
// This will store the total packet size
int packet_size;
// This will store the size of the data in the packet
int data_len;
// This will store the header of a TCP packet
mini_header_reliable_t header_reliable;
// This will store the ACK number of a TCP packet
int ack_num;
// This will store the Sequence number of a TCP packet
int seq_num;
// This will store the socket
minisocket_t socket;
// This will store the TCP error
minisocket_error error;
// This will be used to indicate whether the TCP packet is a duplicate or not
int duplicate = 0;
// This will tell us if we need to free the arg or not
int enqueued;
// Used for general for loops
int i;
// Used to check if we've already broadcasted a route discovery req
int* last_seen_req_id;
// Used for various tasks
network_address_t tmp_addr;
network_address_t tmp_addr2;
// Used to handle routing and discovery requests
route_request_t route_request;
int current_req_id;
int path_len;
int ttl;
// Get the buffer without the routing header
char* buffer_without_routing = (char*) (arg->buffer + sizeof(struct routing_header));
// Used to get the data buffer
char* data_buffer;
// Handle the mini route stuff
// Extract the information from the routing header
routing_header_t routing_header = (routing_header_t) arg->buffer;
char routing_packet_type = routing_header->routing_packet_type;
unpack_address(routing_header->destination, dst_addr);
current_req_id = unpack_unsigned_int(routing_header->id);
ttl = unpack_unsigned_int(routing_header->ttl);
path_len = unpack_unsigned_int(routing_header->path_len);
// Get the data buffer & data length
switch(buffer_without_routing[0])
{
case (char) PROTOCOL_MINISTREAM:
data_buffer = (char*) (buffer_without_routing + sizeof(struct mini_header_reliable));
data_len = arg->size - sizeof(struct routing_header) - sizeof(struct mini_header_reliable);
break;
//default: todo: put this back in, but leave w/o it for testing
case (char) PROTOCOL_MINIDATAGRAM:
data_buffer = (char*) (buffer_without_routing + sizeof(struct mini_header));
data_len = arg->size - sizeof(struct routing_header) - sizeof(struct mini_header);
break;
}
network_get_my_address(my_addr);
//if (network_compare_network_addresses(my_addr, dst_addr) == 0 && ttl == 0)
if (my_addr[0] != dst_addr[0] && ttl == 0)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
switch (routing_packet_type)
{
// If this is a data packet
case ROUTING_DATA:
// If the data packet is meant for us, then break and let the higher
// protocols get the data
unpack_address(routing_header->path[path_len-1], tmp_addr);
if (network_compare_network_addresses(my_addr, tmp_addr) != 0)
{
break;
}
else
{
// If it's not meant for us, we must pass it along
// Go through the path and find the next node
for (i = 0; i < path_len; i++)
{
unpack_address(routing_header->path[i], tmp_addr);
// If this node is us, break - the node we need to send to is next
if (network_compare_network_addresses(tmp_addr, my_addr) != 0)
{
break;
}
}
// If we're the last node (i == path_len-1) or we weren't found in it, quit
if (i >= path_len - 1)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Now we'll forward the packet by reusing the headers we have
// Get the next host in the path and set it as the packet's dst
unpack_address(routing_header->path[i+1], tmp_addr);
pack_unsigned_int(routing_header->ttl, ttl - 1);
// Send the packet onward in the route
network_send_pkt(tmp_addr, arg->size - data_len,
(char*) arg->buffer, data_len, data_buffer);
// Revert the header back (not entirely necessary)
//pack_unsigned_int(routing_header->ttl, ttl);
}
free(arg);
set_interrupt_level(prev_level);
return;
break;
case ROUTING_ROUTE_DISCOVERY:
// We're not the dst, so just forward this packet along
//if (network_compare_network_addresses(my_addr, dst_addr) == 0)
if (my_addr[0] != dst_addr[0])
{
// Check if we're in the path, if so, no need to send again (no loops)
for (i = 0; i < path_len; i++)
{
unpack_address(routing_header->path[i], tmp_addr);
if (network_compare_network_addresses(tmp_addr, my_addr) != 0)
{
break;
}
}
// If we were in the path, return - no need to do anything else
if (i < path_len)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// todo: this next part w/ the discovery packets seen is probably wrong...
// also, lookup the "explain" part in my txt
// todo: need something to clean up old discovery packets
// Check if we've already seen this discovery request - if so, don't resend
last_seen_req_id = (int*) hashmap_get(discovery_packets_seen, current_req_id);
if (last_seen_req_id != NULL)
{
// If this exists, then we've already seen this packet - no need to resend
free(arg);
set_interrupt_level(prev_level);
return;
}
// Now we'll rebroadcast the discovery packet by reusing the header we have
// Modify the header as needed
pack_unsigned_int(routing_header->path_len, path_len+1);
pack_address(routing_header->path[path_len], my_addr);
pack_unsigned_int(routing_header->ttl, ttl - 1);
// Broadcast this packet
network_bcast_pkt(arg->size - data_len, (char*) arg->buffer, data_len, data_buffer);
// Revert the header - dont need to actually remove from route
/*pack_unsigned_int(routing_header->path_len, path_len);
pack_unsigned_int(routing_header->ttl, ttl);
// update already broadcasted hashmap - just put a garbage ptr in
hashmap_insert(discovery_packets_seen, current_req_id, (void*) 0x555555);
*/
free(arg);
set_interrupt_level(prev_level);
return;
}
else
{
// If we were the host being sought, send a reply packet back
// and ensure the higher protocols get the data sent
// reverse the path so we can send a packet back to the host
// Don't forget to add ourselves to the route
path_len++;
pack_unsigned_int(routing_header->path_len, path_len);
pack_address(routing_header->path[path_len-1], my_addr);
for (i = 0; i < path_len/2; i++)
{
unpack_address(routing_header->path[path_len-1-i], tmp_addr);
unpack_address(routing_header->path[i], tmp_addr2);
pack_address(routing_header->path[i], tmp_addr);
pack_address(routing_header->path[path_len-1-i], tmp_addr2);
}
// We'll start sending the packet back now by reusing the header we have
// Prepare the headers
pack_unsigned_int(routing_header->ttl, MAX_ROUTE_LENGTH);
routing_header->routing_packet_type = ROUTING_ROUTE_REPLY;
// send a route reply packet, starting from the next host in the reversed route
unpack_address(routing_header->path[1], tmp_addr);
pack_address(routing_header->destination, tmp_addr);
network_send_pkt(tmp_addr, arg->size - data_len,
(char*) arg->buffer, 0, NULL);
// Revert the header
/*pack_unsigned_int(routing_header->ttl, ttl);
routing_header->routing_packet_type = ROUTING_ROUTE_DISCOVERY;
// Reverse the path back
for (i = 0; i < path_len/2; i++)
{
unpack_address(routing_header->path[path_len-1-i], tmp_addr);
unpack_address(routing_header->path[i], tmp_addr2);
pack_address(routing_header->path[i], tmp_addr);
pack_address(routing_header->path[path_len-1-i], tmp_addr);
}
*/
// DONT return, ensure that the higher protocols will get the data
// ^ never mind. return, it will send a data packet later.
free(arg);
set_interrupt_level(prev_level);
return;
}
break;
case ROUTING_ROUTE_REPLY:
unpack_address(routing_header->path[path_len-1], tmp_addr);
// If we were the initiator of the request and just got our response
//if (network_compare_network_addresses(my_addr, tmp_addr) != 0)
if (my_addr[0] == tmp_addr[0])
{
// Get the addr of the host we were trying to discover
unpack_address(routing_header->path[0], tmp_addr);
// find the discovery request struct for this dst addr
//route_request = (route_request_t) hashmap_get(current_discovery_requests, hash_address(tmp_addr));
route_request = (route_request_t) hashmap_get(current_discovery_requests, tmp_addr[0]);
if (route_request == NULL)
{
free(arg);
set_interrupt_level(prev_level);
return;
// it could be we already got this path
break;
}
// Check if we already got this path, but miniroute_send_pkt() hasn't deleted the req struct yet
if (route_request->interrupt_arg != NULL)
{
free(arg);
set_interrupt_level(prev_level);
return;
break;
}
route_request->interrupt_arg = arg;
semaphore_V(route_request->initiator_sem);
set_interrupt_level(prev_level);
return;
}
else
{
// Find the next node in the route
for (i = 0; i < path_len; i++)
{
unpack_address(routing_header->path[i], tmp_addr);
// Stop if we found ourselves - we need to send to the next node
if (network_compare_network_addresses(tmp_addr, my_addr) != 0)
{
break;
}
}
// If we were the last node OR not in the route at all
if (i >= path_len - 1)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// We'll forward the reply along by reusing the header
// Get the next host in the path and set it as the packet's dst
unpack_address(routing_header->path[i+1], tmp_addr);
pack_unsigned_int(routing_header->ttl, ttl - 1);
pack_address(routing_header->destination, tmp_addr);
// Send the packet onward in the route
network_send_pkt(tmp_addr, arg->size - data_len,
(char*) arg->buffer, 0, NULL);
// Make sure we set the header back
//pack_unsigned_int(routing_header->ttl, ttl);
}
free(arg);
set_interrupt_level(prev_level);
return;
break;
}
// If we're here, the packet was meant for us
// The "normal" packet without the routing header is in buffer_without_routing
// Adjust arg->size in case something uses it
arg->size -= sizeof(struct routing_header);
// Check the protocol
switch (buffer_without_routing[0])
{
case (char) PROTOCOL_MINIDATAGRAM:
// Extract data from the network interrupt arg
//network_address_copy(arg->addr, addr);
// Get the header struct, unpack the parameters
header = (mini_header_t) buffer_without_routing;
dst_port_number = (int) unpack_unsigned_short(header->destination_port);
// Ensure the port number is valid
if (dst_port_number < MIN_UNBOUND || dst_port_number > MAX_UNBOUND)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Then ensure the miniport exists
if (miniports[dst_port_number] == NULL)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Add the arg to the queue
queue_append(miniports[dst_port_number]->port_data.unbound.data_queue, arg);
// Wake up thread that's waiting to receive - sem_V()
semaphore_V(miniports[dst_port_number]->port_data.unbound.data_ready);
// Ensure the argument isn't free'd
enqueued = 1;
set_interrupt_level(prev_level);
return;
break;
case PROTOCOL_MINISTREAM:
// Get the total size of the packet and data length
packet_size = arg->size;
data_len = packet_size - sizeof(struct mini_header_reliable);
// Get the header and extract information
header_reliable = (mini_header_reliable_t) buffer_without_routing;
src_port_number = (int) unpack_unsigned_short(header_reliable->source_port);
dst_port_number = (int) unpack_unsigned_short(header_reliable->destination_port);
unpack_address(header_reliable->source_address, src_addr);
unpack_address(header_reliable->destination_address, dst_addr);
seq_num = (int) unpack_unsigned_int(header_reliable->seq_number);
ack_num = (int) unpack_unsigned_int(header_reliable->ack_number);
// Don't respond if socket doesn't exist - will trigger SOCKET_NOSERVER for client
if (minisockets[dst_port_number] == NULL)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Get the socket in question
socket = minisockets[dst_port_number];
// Check if packet was meant for us - ignore if not
network_get_my_address(my_addr);
if (network_compare_network_addresses(my_addr, dst_addr) == 0)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
if (socket->status == TCP_PORT_CLOSING || socket->waiting == TCP_PORT_WAITING_CLOSE)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Packet handling for established connections
if (socket->status != TCP_PORT_LISTENING)
{
// Ensure source address is correct - ignore if not
if (network_compare_network_addresses(src_addr, socket->dst_addr) == 0
|| src_port_number != socket->dst_port)
{
if (header_reliable->message_type == MSG_SYN)
{
// A client is trying to connect to an already-connected port
// Send them a FIN, which will result in their client
// returning a SOCKET_BUSY error
transmit_packet(socket, src_addr, src_port_number, 0,
MSG_FIN, 0, NULL, &error);
}
free(arg);
set_interrupt_level(prev_level);
return;
}
/* We got a duplicate SYN and need to ensure that the host gets
* another SYNACK. The thread that sent the SYNACK will currently
* be retransmitting the SYNACKs, as it didn't get an ACK. If it
* was done with the retransmission sequence, the socket would be
* closed, and this would therefore not have gotten this far.
* HOWEVER:
* If the retransmission sequence already sent its LAST
* retransmission and was waiting on it, then this duplicate SYN
* will NOT get a SYNACK, as the retransmission is just waiting
* out the last alarm before it ends. Therefore, if this is the case,
* reset the timeout to the last timeout value so it sends just
* one more SYNACK.
*
* Professor Sirer mentioned that this isn't even necessary,
* but this does seem to make the code follow the specs more.
*/
if (header_reliable->message_type == MSG_SYN)
{
// If the timeout is at 6400, then it's the last transmission
// but it hasn't been doubled yet. If it's 12800, it's just
// been doubled. In each case we want to keep it at 6400
// at the end of the while loop, so we set the timeout to half
// it's current value.
if (socket->timeout >= 6400)
{
socket->timeout /= 2;
}
free(arg);
set_interrupt_level(prev_level);
return;
}
// If we were trying to connect and got a FIN, that means the socket's busy
if (socket->status == TCP_PORT_CONNECTING && header_reliable->message_type == MSG_FIN)
{
// Not connected, got a FIN - that means we couldnt start connection b/c it was busy
// This will let the client function infer that
socket->status = TCP_PORT_COULDNT_CONNECT;
// Wake it up so it can end the retransmission sequence
semaphore_V(socket->wait_for_ack_sem);
free(arg);
set_interrupt_level(prev_level);
return;
}
/* Note: the code below handles ACKs. It also inherently deals with
* duplicate ACKs. We have a status code that indicates whether the socket
* is waiting for an ACK or not. If it's set and we get an ACK (or any
* packet) with the right ACK number, we can process it. However, if our
* status indicates we're NOT waiting for an ACK, we can infer from the
* fact that window_size = 1 that we already got the only ACK we could've
* been expecting, and this new one is therefore a duplicate.
*/
// If we're waiting on an ACK
if (socket->waiting == TCP_PORT_WAITING_ACK /*|| socket->waiting == TCP_PORT_WAITING_ACK_WAKING*/)
{
// This can be an ACK or really any other data packet, we just
// need the ACK number
if (ack_num == socket->seq_num)
{
// Update our status to show we're no longer waiting for an ACK
socket->waiting = TCP_PORT_WAITING_NONE;
// Wake up the thread waiting for the ACK
semaphore_V(socket->wait_for_ack_sem);
}
else if (ack_num == socket->seq_num - 1)
{
// This follows the same logic from the comment block around
// line 170.
if (socket->timeout >= 6400)
{
socket->timeout /= 2;
}
}
}
// If it's an ACK, it requires no further processing
if (header_reliable->message_type == MSG_ACK && data_len == 0)
{
free(arg);
set_interrupt_level(prev_level);
return;
}
// Check if it's a SYNACK we're waiting for
if (socket->waiting == TCP_PORT_WAITING_SYNACK && header_reliable->message_type == MSG_SYNACK)
{
// We're now fully connected in our eyes, handshake complete
socket->waiting = TCP_PORT_WAITING_NONE;
semaphore_V(socket->wait_for_ack_sem);
}
// If we're here, the packet isnt an ACK or SYN, so we should ACK it
// First check if we should increment our ack number
if (seq_num == socket->ack_num + 1)
{
socket->ack_num++;
}
else
{
// It's a duplicate, don't add to queue
duplicate = 1;
}
// Next, perform the ACK, don't incr the seq#
transmit_packet(socket, socket->dst_addr, socket->dst_port,
0, MSG_ACK, 0, NULL, &error);
/* Note: the code below handles FINs, and is also protected against
* duplicate FINs inherently. The seq_num == ack_num check doesn't
* guarantee it's not a duplicate; however, if we process one FIN,
* then the socket's status is set to TCP_PORT_CLOSING. Therefore,
* if we get another FIN, we can tell that the port is already closing
* and we don't need to process it, which also ensures we don't
* process duplicate FINs multiple times. We'll include the
* duplicate == 0 check just for good measure, however.
*/
// We're required to close the conn 15s after we ACK a FIN, so do that here
if (seq_num == socket->ack_num
&& header_reliable->message_type == MSG_FIN
&& socket->status != TCP_PORT_CLOSING
&& duplicate == 0)
{
socket->status = TCP_PORT_CLOSING;
queue_append(sockets_to_delete, socket);
semaphore_V(socket_needs_delete);
}
}
else if (socket->status == TCP_PORT_LISTENING)
{
// Start a connection with the client
if (header_reliable->message_type == MSG_SYN)
{
// Update socket's dst addr & dst port to the client's
network_address_copy(src_addr, socket->dst_addr);
socket->dst_port = src_port_number;
// Set the status to connecting
socket->status = TCP_PORT_CONNECTING;
// Awake the create_server thread, it'll handle the rest
semaphore_V(socket->wait_for_ack_sem);
}
}
// Add the packet to the socket's packet queue if not duplicate & it's a data pkt
if (duplicate == 0 && header_reliable->message_type == MSG_ACK && data_len != 0)
{
enqueued = 1;
queue_append(socket->waiting_packets, arg);
if (socket->data_len == 0)
semaphore_V(socket->packet_ready);
}
// remember to free arg if we dont push this to the tcp recv queue
break;
}
if (enqueued == 0)
{
free(arg);
}
// Restore the interrupt level
set_interrupt_level(prev_level);
return;
}
minisocket_t* minisocket_client_create(const network_address_t addr, int port, minisocket_error *error) {
//Check socket number first
if (valid_server_port(port) == 0) {
*error = SOCKET_INVALIDPARAMS;
return NULL;
}
//Then check if we can make another client
if (client_count >= MAX_CLIENTS) {
*error = SOCKET_NOMOREPORTS;
return NULL;
}
//create new minisocket
minisocket_t* socket = (minisocket_t *) malloc(sizeof(minisocket_t));
if (socket == NULL) {
*error = SOCKET_OUTOFMEMORY;
return NULL; //OOM
}
while (mini_socket_data[next_port]) {
next_port = ((next_port + 1) % PORT_RANGE);
}
socket->socket_type = CLIENT_TYPE;
socket->local_port_number = next_port;
next_port = ((next_port + 1) % PORT_RANGE);
socket->state = CONNECTING;
socket->seq = 0;
socket->ack = 0;
network_address_copy(addr, socket->remote_address);
socket->remote_port_number = (unsigned short) port;
network_address_copy(addr, socket->remote_address);
socket->next_read = 0;
network_address_t my_address;
network_get_my_address(my_address);
network_address_copy(my_address, socket->local_address);
socket->datagrams_ready = semaphore_create();
semaphore_initialize(socket->datagrams_ready, 0);
socket->ack_ready = semaphore_create();
semaphore_initialize(socket->ack_ready, 0);
socket->incoming_data = queue_new();
socket->acknowledgements = queue_new();
//add socket to global array
mini_socket_data[socket->local_port_number] = socket;
mini_header_reliable_t header;
minisocket_create_reliable_header((mini_header_reliable_t *) &header, socket, socket->remote_port_number, addr, MSG_SYN);
//minisocket and header now created, try to establish connection
pack_unsigned_int(header.seq_number, socket->seq);
pack_unsigned_int(header.ack_number, socket->ack);
//send first message and wait for response
int response = 0; //no response yet
int timeout = START_TIMEOUT / 2; //this way first timeout will be at START_TIMEOUT
for (int i = 0; i < MAX_FAILURES; i++) {
printf("sending MSG_SYN in client, i: %d\n", i);
timeout = timeout * 2;
network_send_pkt(addr, sizeof(mini_header_reliable_t), (char *) &header, 0, empty_message);
alarm_id timeout_alarm_id = register_alarm(timeout, handshake_timeout_handler, (void *) socket->ack_ready);
int alarm_fired = 0;
while (!response && !alarm_fired) {
semaphore_P(socket->ack_ready);
//If queue length == 0, then the alarm must have fired
if (queue_length(socket->acknowledgements) == 0) {
alarm_fired = 1; //goes to next iteration of for loop
}
//otherwise, we received a packet
else {
network_interrupt_arg_t *interrupt_message;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
queue_dequeue(socket->acknowledgements, (void **) &interrupt_message);
set_interrupt_level(old_level);
// if message not null
if (interrupt_message != NULL) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
network_address_t temp_address;
unpack_address(received_header->source_address, temp_address);
if (socket->remote_port_number == unpack_unsigned_short(received_header->source_port) &&
network_compare_network_addresses(socket->remote_address, temp_address) != 0) {
//if SYNACK
printf("CLIENT\n");
if (received_header->message_type == MSG_SYNACK) {
printf("GOT message SYN_ACK\n");
deregister_alarm(timeout_alarm_id);
response = 1;
break;
}
//if MSG_FIN
else if (received_header->message_type == MSG_FIN) {
printf("got message MSG_FIN in client\n");
//server already in use
deregister_alarm(timeout_alarm_id);
*error = SOCKET_BUSY;
response = 1;
minisocket_destroy(socket);
return NULL;
}
//WRONG MESSAGE TYPE
else {
printf("wrong message type received in client\n");
//TODO : try another message type, maybe do nothing?
}
}
}
}
}
if (response) {
break;
}
}
// timeout after 12.8s occured, close down socket
if (response != 1) {
printf("full timeout in client sending SYN\n");
*error = SOCKET_NOSERVER;
minisocket_destroy(socket);
return NULL;
}
// send final MSG_ACK once to server (future data packets will also have MSG_ACK as header type)
header.message_type = MSG_ACK;
printf("sending final MSG_ACK and leaving client create\n");
network_send_pkt(addr, sizeof(mini_header_reliable_t), (char *) &header, 0, empty_message);
socket->state = CONNECTED;
client_count++;
return socket;
}
/* Takes in a routing packet and does error checking.
* Adds it to the cache if this packet was destined for us.
* Returns 1 if this packet has data to be passed along,
* O otherwise.
*/
int miniroute_process_packet(network_interrupt_arg_t* pkt) {
struct routing_header* pkt_hdr = NULL;
network_address_t tmp_addr;
network_address_t src_addr;
network_address_t dst_addr;
network_address_t nxt_addr;
unsigned int discovery_pkt_id;
unsigned int pkt_ttl;
unsigned int path_len;
miniroute_t path = NULL;
miniroute_t new_path = NULL;
network_address_t* new_route = NULL;
unsigned int i;
unsigned int found;
struct routing_header hdr;
char tmp;
dcb_t control_block;
//printf("entering miniroute_process_packet\n");
if (pkt == NULL || pkt->size < sizeof(struct routing_header)) {
//printf("exiting miniroute_process_packet on INVALID PARAMS\n");
return 0;
}
pkt_hdr = (struct routing_header*)pkt->buffer;
unpack_address(pkt_hdr->destination, dst_addr);
discovery_pkt_id = unpack_unsigned_int(pkt_hdr->id);
pkt_ttl = unpack_unsigned_int(pkt_hdr->ttl);
path_len = unpack_unsigned_int(pkt_hdr->path_len);
unpack_address(pkt_hdr->path[0], src_addr);
if (network_compare_network_addresses(my_addr, dst_addr)) {
//same
if (!miniroute_cache_get(route_cache, src_addr)) {
//not in cache
if (pkt_hdr->routing_packet_type == ROUTING_ROUTE_DISCOVERY) {
//add myself to the path vector
pack_address(pkt_hdr->path[path_len], my_addr);
path_len++;
pack_unsigned_int(pkt_hdr->path_len, path_len);
}
new_route = (network_address_t*)calloc(path_len, sizeof(network_address_t));
if (new_route == NULL) {
free(pkt);
//printf("exiting miniroute_process_packet on CALLOC ERROR\n");
return 0;
}
for (i = 0; i < path_len; i++) {
unpack_address(pkt_hdr->path[path_len - i - 1], tmp_addr);
network_address_copy(tmp_addr, new_route[i]);
}
new_path = (miniroute_t)calloc(1, sizeof(struct miniroute));
if (new_path == NULL) {
free(pkt);
free(new_route);
//printf("exiting miniroute_process_packet on CALLOC ERROR\n");
return 0;
}
new_path->route = new_route;
new_path->len = path_len;
miniroute_cache_put(route_cache, src_addr, new_path);
} //added new route to cache
}
else if (pkt_ttl <= 0) {
free(pkt);
//printf("exiting miniroute_process_packet on TTL ERROR\n");
return 0;
}
else if (pkt_hdr->routing_packet_type != ROUTING_ROUTE_DISCOVERY) {
//different
//check from 2nd to second to last address
found = 0;
for (i = 1; i < path_len - 1; i++) {
unpack_address(pkt_hdr->path[i], tmp_addr);
if (network_compare_network_addresses(my_addr, tmp_addr)) {
unpack_address(pkt_hdr->path[i+1], nxt_addr);
found = 1;
break;
}
}
if (!found) {
free(pkt);
return 0;
}
}
switch (pkt_hdr->routing_packet_type) {
case ROUTING_DATA:
//printf("got a DATA pkt\n");
if (network_compare_network_addresses(my_addr, dst_addr)) {
//same
//printf("exiting miniroute_process_packet on DATA PKT\n");
return 1;
}
else {
//skip packet type, shouldn't change
//skip destination, shouldn't change
//skip id, shouldn't change
pack_unsigned_int(pkt_hdr->ttl, pkt_ttl - 1); //subtract ttl
network_send_pkt(nxt_addr, sizeof(struct routing_header), (char*)pkt_hdr, 0, &tmp);
}
break;
case ROUTING_ROUTE_DISCOVERY:
if (network_compare_network_addresses(my_addr, dst_addr)) {
//printf("got a DISCOVERY pkt, for me\n");
//same
path = miniroute_cache_get(route_cache, src_addr);
hdr.routing_packet_type = ROUTING_ROUTE_REPLY;
pack_address(hdr.destination, src_addr);
pack_unsigned_int(hdr.id, discovery_pkt_id);
pack_unsigned_int(hdr.ttl, MAX_ROUTE_LENGTH);
pack_unsigned_int(hdr.path_len, path->len);
for (i = 0; i < path->len; i++) {
pack_address(hdr.path[i], path->route[i]);
}
network_send_pkt(path->route[1], sizeof(struct routing_header), (char*)(&hdr), 0, &tmp);
}
else {
//printf("got a DISCOVERY pkt, for someone else\n");
//different
//scan to check if i am in list
//if yes then discard
//else append to path vector and broadcast
//
//scan to check if i am in list
//if yes then pass along, else discard
for (i = 0; i < path_len - 1; i++) {
unpack_address(pkt_hdr->path[i], tmp_addr);
if (network_compare_network_addresses(my_addr, tmp_addr)) {
free(pkt);
// printf("exiting miniroute_process_packet on BROADCAST LOOP\n");
return 0;
}
}
//printf("checks passed\n");
pack_address(pkt_hdr->path[path_len], my_addr);
pack_unsigned_int(pkt_hdr->path_len, path_len + 1); //add path_len
pack_unsigned_int(pkt_hdr->ttl, pkt_ttl - 1); //subtract ttl
//printf("packet header configured\n");
//printf("my addr is (%i,%i)\n", my_addr[0], my_addr[1]);
//printf("source addr is (%i,%i)\n", src_addr[0], src_addr[1]);
//printf("dst addr is (%i,%i)\n", dst_addr[0], dst_addr[1]);
//for (i = 0 ; i < path_len + 1; i++){
//unpack_address(pkt_hdr->path[i], tmp_addr);
//printf("->(%i,%i)", tmp_addr[0], tmp_addr[1]);
//}
//printf("\n");
network_bcast_pkt(sizeof(struct routing_header), (char*)pkt_hdr, 0, &tmp); //send to neighbors
//printf("broadcast successful\n");
}
break;
case ROUTING_ROUTE_REPLY:
//printf("got a REPLY pkt\n");
if (network_compare_network_addresses(my_addr, dst_addr)) {
//same
control_block = hash_table_get(dcb_table, src_addr);
if (control_block) {
deregister_alarm(control_block->resend_alarm);
control_block->resend_alarm = NULL;
control_block->alarm_arg = NULL;
semaphore_V(control_block->route_ready);
}
}
else {
//different
//check ttl
//scan to check if i am in list
//if yes then pass along, else discard
//
//skip packet type, shouldn't change
//skip destination, shouldn't change
//skip id, shouldn't change
pack_unsigned_int(pkt_hdr->ttl, pkt_ttl - 1); //subtract ttl
network_send_pkt(nxt_addr, sizeof(struct routing_header), (char*)pkt_hdr, 0, &tmp);
}
break;
default:
//WTFFF???
break;
}
//printf("exiting miniroute_process_packet on SUCCESS\n");
free(pkt);
return 0;
}
int minisocket_send(minisocket_t *socket, const char *msg, int len, minisocket_error *error)
{
if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) {
*error=SOCKET_SENDERROR;
return 0;
}
if (!socket || socket->socket_state != OPEN || !msg || len == 0)
{
*error = SOCKET_INVALIDPARAMS;
return -1;
}
semaphore_P(socket->send_receive_mutex);
int fragment_length = MAX_NETWORK_PKT_SIZE - sizeof(mini_header_reliable_t);
int transfer_length = len > fragment_length ? fragment_length : len;
//int start_byte = 0;
int sent_byte = 0;
do {
int wait = 100;
mini_header_reliable_t *header = create_control_header(MSG_ACK, socket->remote_port,
socket->remote_addr, socket->local_port,
socket->seq_number, socket->ack_number);
transfer_length = len - sent_byte > fragment_length ? fragment_length : len - sent_byte;
while (wait <= 12800) {
socket->ack_flag = 0;
int res = network_send_pkt(socket->remote_addr, sizeof(mini_header_reliable_t),
(char *)header, transfer_length, msg + sent_byte);
socket->seq_number += transfer_length;
if (res == -1) {
*error = SOCKET_SENDERROR;
semaphore_V(socket->send_receive_mutex);
return (sent_byte == 0) ? -1 : sent_byte;
}
alarm_id a = register_alarm(wait, (alarm_handler_t) semaphore_V, socket->data_ready);
semaphore_P(socket->wait_for_ack);
if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) {
*error=SOCKET_SENDERROR;
return 0;
}
interrupt_level_t old_level = set_interrupt_level(DISABLED);
// Function was woken up by the firing of the alarm
if (socket->ack_flag == 0) {
wait *= 2;
socket->seq_number -= transfer_length;
semaphore_V(socket->send_receive_mutex);
set_interrupt_level(old_level);
continue;
}
// Function was woken up by the network handler
else if (socket->ack_flag == 1) {
// ACK has been received
deregister_alarm(a);
sent_byte += transfer_length;
semaphore_V(socket->send_receive_mutex);
set_interrupt_level(old_level);
break;
}
}
if (wait > 12800) {
*error = SOCKET_SENDERROR;
semaphore_V(socket->send_receive_mutex);
return (sent_byte == 0) ? -1 : sent_byte;
}
} while (sent_byte != len);
semaphore_V(socket->send_receive_mutex);
return len;
}
//Transmit a packet and handle retransmission attempts
int transmit_packet(minisocket_t socket, network_address_t dst_addr, int dst_port,
short incr_seq, char message_type, int data_len, char* data,
minisocket_error* error)
{
mini_header_reliable_t newReliableHeader;
void *alarmId;
int sendSucessful;
network_address_t my_addr;
int success = 0;
int connected = 0;
if (message_type == MSG_ACK)
connected = 1;
network_get_my_address(my_addr);
if (socket == NULL)
{
*error = SOCKET_INVALIDPARAMS;
return -1;
}
if (socket->status == TCP_PORT_CLOSING)
{
*error = SOCKET_SENDERROR;
return -1;
}
newReliableHeader = create_reliable_header(my_addr, socket->port_number, dst_addr,
dst_port, message_type, socket->seq_number, socket->ack_number);
socket->timeout = 100;
while(socket->timeout <= 6400)
{
printf("sending packet to %d, seq=%d, ack=%d, type=%d\n", dst_port, socket->seq_number, socket->ack_number, message_type);
sendSucessful = network_send_pkt(dst_addr, sizeof(struct mini_header_reliable),
(char*) newReliableHeader, data_len, (char*) data);
if (sendSucessful == -1)
{
socket->timeout *= 2;
continue;
}
alarmId = register_alarm(socket->timeout, &wake_up_semaphore, socket);
if (message_type == MSG_SYN)
{
socket->waiting = TCP_PORT_WAITING_SYNACK;
semaphore_P(socket->wait_for_ack_semaphore);
}
else if (!connected)
{
socket->waiting = TCP_PORT_WAITING_ACK;
semaphore_P(socket->wait_for_ack_semaphore);
}
else {
socket->waiting = TCP_PORT_WAITING_NONE;
}
semaphore_P(socket->mutex);
if (socket->waiting == TCP_PORT_WAITING_NONE)
{
/* I think incr_seq belongs before the _P on wait_for_ack, but that breaks it for now :/
if (incr_seq)
{
semaphore_P(socket->mutex);
socket->seq_number++;
semaphore_V(socket->mutex);
}
*/ if (message_type == MSG_SYN)
{
//we got a synack back, so we need to make sure to send an ack to the server
newReliableHeader = create_reliable_header(my_addr, socket->port_number, dst_addr,
dst_port, MSG_ACK, socket->seq_number, socket->ack_number);
socket->timeout = 100;
message_type = MSG_ACK;
connected = 1;
semaphore_V(socket->mutex);
continue;
}
deregister_alarm(alarmId);
success = 1;
semaphore_V(socket->mutex);
break;
}
else
{
if (socket->status == TCP_PORT_UNABLE_TO_CONNECT)
{
deregister_alarm(alarmId);
success = 0;
semaphore_V(socket->mutex);
break;
}
socket->timeout *= 2;
semaphore_V(socket->mutex);
}
}
semaphore_P(socket->mutex);
socket->timeout = 100;
if (success == 0)
{
socket->waiting = TCP_PORT_WAITING_NONE;
*error = SOCKET_NOSERVER;
}
semaphore_V(socket->mutex);
*error = SOCKET_NOERROR;
free(newReliableHeader);
return 0;
}
int minisocket_send(minisocket_t *socket, const char *msg, int len, minisocket_error *error) {
//Check params
if (socket == NULL || mini_socket_data[socket->local_port_number] != socket || len < 0 || msg == NULL) {
*error = SOCKET_INVALIDPARAMS;
return -1;
}
if (socket->state == CLOSED) {
*error = SOCKET_SENDERROR;
return -1;
}
if (len == 0) {
return 0;
}
//can't send more bytes than we have
if (len > strlen(msg)) {
len = strlen(msg);
}
int bytes_sent = 0;
int max_data_size = MAX_NETWORK_PKT_SIZE - sizeof(mini_header_reliable_t);
int data_left = len;
int packet_size;
mini_header_reliable_t header;
minisocket_create_reliable_header((mini_header_reliable_t *) &header, socket, socket->remote_port_number, socket->remote_address, MSG_ACK);
//Keep sending until all is sent
while (data_left != 0) {
if (data_left >= max_data_size) {
packet_size = max_data_size;
}
else {
packet_size = data_left;
}
data_left -= packet_size;
pack_unsigned_int(header.seq_number, socket->seq);
int send_success = 0;
//Attempt to send message
int timeout = START_TIMEOUT/2;
for (int i = 0; i < MAX_FAILURES; i++) {
//printf("i: %d\n", i);
timeout = timeout * 2;
//update the seq and ack numbers for the header from the socket
//printf("seq: %u, ack: %u\n", socket->seq, socket->ack);
pack_unsigned_int(header.ack_number, socket->ack);
pack_unsigned_int(header.seq_number, socket->seq);
network_send_pkt(socket->remote_address, sizeof(mini_header_reliable_t), (char *) &header, packet_size, (char *) msg);
alarm_id timeout_alarm_id = register_alarm(timeout, handshake_timeout_handler, (void *) socket->ack_ready);
int alarm_fired = 0;
//keep looking through received packets until either the alarm fires or it finds the correct packet
while (!send_success && !alarm_fired) {
semaphore_P(socket->ack_ready);
if (queue_length(socket->acknowledgements) == 0) {
// printf("no message in queue\n");
alarm_fired = 1; //goes to next iteration of for loop
}
else {
// printf("length of queue currently %d\n", queue_length(socket->acknowledgements));
network_interrupt_arg_t* interrupt_message = NULL;
interrupt_level_t old_level = set_interrupt_level(DISABLED);
queue_dequeue(socket->acknowledgements, (void **) &interrupt_message);
set_interrupt_level(old_level);
if (interrupt_message != NULL) {
mini_header_reliable_t* received_header = (mini_header_reliable_t *) interrupt_message->buffer;
network_address_t temp_address;
unpack_address(received_header->source_address, temp_address);
unsigned int new_ack = unpack_unsigned_int(received_header->ack_number);
//printf("Received an acknowledgment with ack number %u \n", new_ack);
if (socket->remote_port_number == unpack_unsigned_short(received_header->source_port) &&
network_compare_network_addresses(socket->remote_address, temp_address) != 0 &&
received_header->message_type == MSG_ACK && new_ack == (socket->seq + packet_size)) {
//same address, same ports, right message, right ack
deregister_alarm(timeout_alarm_id); //only deregister alarm when the right packet is found
send_success = 1;
bytes_sent += packet_size;
msg += packet_size;
socket->seq += packet_size;
free(interrupt_message);
break;
}
else {
free(interrupt_message);
}
}
}
}
if (send_success) {
break;
}
}
if (!send_success) { //Got a timeout, should close down socket
*error = SOCKET_SENDERROR;
minisocket_destroy(socket);
return bytes_sent;
}
}
//printf("\n\n");
return bytes_sent;
}
/* sends a miniroute packet, automatically discovering the path if necessary.
* See description in the .h file.
*/
int miniroute_send_pkt(network_address_t dest_address, int hdr_len,
char* hdr, int data_len, char* data) {
interrupt_level_t l;
miniroute_t path;
dcb_t control_block;
struct routing_header new_hdr;
int i;
int path_len;
int new_data_len;
char* new_data;
int bytes_sent;
//printf("entering miniroute_send_pkt\n");
if (hdr_len < 0 || data_len < 0 || hdr == NULL || data == NULL) {
//printf("invalid params\n");
return -1;
}
path = miniroute_discover_route(dest_address);
if (path == NULL) {
return -1;
}
l = set_interrupt_level(DISABLED);
control_block = hash_table_get(dcb_table, dest_address);
if (control_block != NULL && control_block->count == 0) {
//no threads are blocked on route. cleanup
semaphore_destroy(control_block->mutex);
semaphore_destroy(control_block->route_ready);
hash_table_remove(dcb_table, dest_address);
free(control_block);
//printf("destroyed a discovery control block\n");
}
set_interrupt_level(l);
//JUST DO IT
new_hdr.routing_packet_type = ROUTING_DATA;
pack_address(new_hdr.destination, dest_address);
pack_unsigned_int(new_hdr.ttl, MAX_ROUTE_LENGTH);
pack_unsigned_int(new_hdr.id, 0);
pack_unsigned_int(new_hdr.path_len, path->len);
if (path->len > MAX_ROUTE_LENGTH) {
path_len = MAX_ROUTE_LENGTH;
}
else {
path_len = path->len;
}
for (i = 0; i < path_len; i++) {
pack_address(new_hdr.path[i], path->route[i]);
}
new_data_len = hdr_len + data_len;
new_data = (char*)malloc(new_data_len);
memcpy(new_data, hdr, hdr_len);
memcpy(new_data+hdr_len, data, data_len);
bytes_sent = network_send_pkt(path->route[1], sizeof(struct routing_header),
(char*)&new_hdr, new_data_len, new_data);
free(new_data);
if ((bytes_sent - hdr_len) < 0) {
//printf("exiting miniroute_send_pkt on FAILURE\n");
return -1;
}
else {
//printf("exiting miniroute_send_pkt on SUCCESS\n");
return (bytes_sent - hdr_len);
}
}
/* sends a miniroute packet, automatically discovering the path if necessary. See description in the
* .h file.
*/
int miniroute_send_pkt(network_address_t dest_address, int hdr_len, char* hdr, int data_len, char* data)
{
// This will store the route request struct, which is a structure related to the
// search for a path to the host
route_request_t route_request;
// Store the routing header
routing_header_t routing_header;
// Store the route to the host, which is an array of addresses
network_address_t* route;
// Store the route data struct, which holds the route and some metadata
route_data_t route_data;
// Store my address
network_address_t my_addr;
// Used to synchronize access with structures the network handler touches
interrupt_level_t prev_level;
// This will store the combined routing + normal headers
char* full_header;
network_address_t dest_address2;
// These will store data related to the routes
int time_route_found;
int route_len;
int route_valid = 1;
// Used to get data from the header containing the paht
routing_header_t tmp_routing_header;
// Used to just check the IP of senders; combats UDP port issues w/ simulated broadcasts
unsigned int dest_address_ip = dest_address[0];
// Loop + tmp variables
int current_req_id;
int success = 0;
int alarm_id;
int x;
int i;
if (hdr_len == 0 || hdr == NULL
|| data_len == 0 || data == NULL)
return -1;
// Get the route item, which is a hashmap_item_t, from the hashmap for this addr
semaphore_P(route_cache_sem);
route_data = (route_data_t) hashmap_get(route_cache, hash_address(dest_address));
// If it's not NULL, extract the data from the item
if (route_data != NULL)
{
time_route_found = route_data->time_found;
route_len = route_data->route_len;
// caveat: the cleanup thread may delete the route data, so we need to
// save it in a separate variable, just incase.
route = (network_address_t*) malloc(sizeof(network_address_t) * route_len);
if (route == NULL)
{
semaphore_V(route_cache_sem);
return -1;
}
memcpy(route, route_data->route, sizeof(network_address_t) * route_len);
}
else
{
route_valid = 0;
}
semaphore_V(route_cache_sem);
// Check, if the route isn't NULL, if it's expired
if (route_valid == 1 && (ticks - time_route_found) * PERIOD/MILLISECOND > 3000)
{
route_valid = 0;
}
// If the route is invalid (either not in the cache or expired)...
if (route_valid == 0)
{
// We won't be needing that previous route variable
if (route_data != NULL)
{
// But, just in case someone is still using it, use the route cache semaphore
semaphore_P(route_cache_sem);
free(route);
semaphore_V(route_cache_sem);
}
// Check if someone else already initiated this route discovery request
prev_level = set_interrupt_level(DISABLED);
route_request = (route_request_t) hashmap_get(current_discovery_requests, dest_address_ip);
set_interrupt_level(prev_level);
// If so, we can just wait for their result
if (route_request != NULL)
{
// Wait for the other thread to get the path
// The threads waiting variable needs to be synchronized. We decided
// to reuse the route cache sem, as there will not be much lock
// contention
semaphore_P(route_cache_sem);
route_request->threads_waiting++;
semaphore_V(route_cache_sem);
semaphore_P(route_request->waiting_sem);
// Get the route from the hashmap
semaphore_P(route_cache_sem);
route_data = (route_data_t) hashmap_get(route_cache, hash_address(dest_address));
// If the other thread didn't get the route, return an error
if (route_data == NULL)
{
// Return failure...
semaphore_V(route_cache_sem);
return -1;
}
else
{
time_route_found = route_data->time_found;
route_len = route_data->route_len;
if ((ticks - time_route_found) * PERIOD/MILLISECOND > 3000)
{
// This could have been a left-over expired cache entry that we haven't
// deleted yet.
semaphore_V(route_cache_sem);
return -1;
}
// Save the route in a separate variable in case the route gets cleaned up
// while we're using it
route = (network_address_t*) malloc(sizeof(network_address_t) * route_len);
if (route == NULL)
{
semaphore_V(route_cache_sem);
return -1;
}
memcpy(route, route_data->route, sizeof(network_address_t) * route_len);
semaphore_V(route_cache_sem);
}
}
else
{
// Otherwise, we have to do the route discovery process
// Create a new route request struct
route_request = create_route_request();
if (route_request == NULL)
{
return -1;
}
// Add the route request to the current discovery requests
prev_level = set_interrupt_level(DISABLED);
hashmap_insert(current_discovery_requests, dest_address_ip, route_request);
set_interrupt_level(prev_level);
// We'll try the route discovery process three times
for (i = 0; i < 3; i++)
{
// Register an alarm to wake this thread up as it waits for a response
alarm_id = register_alarm(12000, &alarm_wakeup_sem, (void*) route_request->initiator_sem);
// Increment the request ID - must be synchronized, obviously
semaphore_P(request_id_sem);
current_req_id = route_request_id++;
semaphore_V(request_id_sem);
// We need to make a header for the discovery request, but the path
// needs to have our address in it, so the reply can be forwarded back
// to us
network_get_my_address(my_addr);
// Passing in the address of this local variable will suffice, as the
// value is immediately copied into the header and then not used again
// Create a routing header for the route discovery request
routing_header = create_miniroute_header(ROUTING_ROUTE_DISCOVERY,
dest_address, current_req_id,
MAX_ROUTE_LENGTH, 1,
&my_addr);
if (routing_header == NULL)
{
return -1;
}
// Combine it with the given header
full_header = merge_headers(routing_header, hdr, hdr_len);
if (full_header == NULL)
{
free(routing_header);
return -1;
}
// Send out the route discovery request
network_bcast_pkt(sizeof(struct routing_header)+hdr_len,
(char*) full_header, data_len, data);
// Wait for a reply (which will be signalled by the network handler)
prev_level = set_interrupt_level(DISABLED);
semaphore_P(route_request->initiator_sem);
set_interrupt_level(prev_level);
// Check if we got a successful response
if (route_request->interrupt_arg != NULL)
{
// Deregister the alarm before it tries to wake us up
// Needs to be synchronized, as the IH touches it and we destroy it here
prev_level = set_interrupt_level(alarm_id);
deregister_alarm(alarm_id);
set_interrupt_level(alarm_id);
// Get the header
tmp_routing_header = (routing_header_t) route_request->interrupt_arg->buffer;
route_len = unpack_unsigned_int(tmp_routing_header->path_len);
// Then the path, for our own use later in this function
// We'll also create one copy and put it in the route data struct
route = miniroute_reverse_raw_path(tmp_routing_header, route_len);
if (route == NULL)
{
free(routing_header);
free(full_header);
return -1;
}
// Create a route data struct - with a different route (as it will be deleted by a diff thread)
route_data = create_route_data(miniroute_reverse_raw_path(tmp_routing_header, route_len),
route_len, ticks);
if (route_data == NULL)
{
free(routing_header);
free(full_header);
return -1;
}
// add it to the cache hashmap
semaphore_P(route_cache_sem);
hashmap_insert(route_cache, hash_address(dest_address), route_data);
semaphore_V(route_cache_sem);
// Wake up the other threads waiting
for (x = 0; x < route_request->threads_waiting; x++)
{
semaphore_V(route_request->waiting_sem);
}
// Clean up the route request struct, then delete it from the hashmap
// DELETE ROUTE REQUEST WILL FREE THE NETWORK INTERRUPT ARG!
prev_level = set_interrupt_level(DISABLED);
delete_route_request(route_request);
hashmap_delete(current_discovery_requests, dest_address_ip);
set_interrupt_level(prev_level);
// We don't need to actually get any of the routing stuff from the
// route_ite, as this process also sent the data packet
// Free the headers
free(routing_header);
free(full_header);
// Return the total bytes sent, not including the routing header
success = 1;
break;
}
}
// If we didn't get a successful response after 3 tries...
if (success == 0)
{
// Wake up the other threads waiting so they can see we failed
for (x = 0; x < route_request->threads_waiting; x++)
{
semaphore_V(route_request->waiting_sem);
}
// clean up the route request struct, then delete it from the hashmap
prev_level = set_interrupt_level(DISABLED);
delete_route_request(route_request);
hashmap_delete(current_discovery_requests, dest_address_ip);
set_interrupt_level(prev_level);
// Free the headers
free(routing_header);
free(full_header);
// Return failure...
return -1;
}
}
}
// If we're here, we either found the route in the cache or waited for another
// thread to finish getting the route (and it did so successfully)
network_address_copy(route[route_len-1], dest_address2);
// Need to update the dst address to deal with UDP port issues
// This again is due to UDP port issues...
pack_address(((mini_header_t) hdr)->destination_address, dest_address2);
// Create a routing header for the data packet
routing_header = create_miniroute_header(ROUTING_DATA,
dest_address2, 0,
MAX_ROUTE_LENGTH, route_len,
route);
if (routing_header == NULL)
{
return -1;
}
// Combine it with the given header
full_header = merge_headers(routing_header, hdr, hdr_len);
if (full_header == NULL)
{
free(routing_header);
}
// Set the right destination address
network_address_copy(route[1], dest_address2);
// Send the packet
network_send_pkt(dest_address2, sizeof(struct routing_header) + hdr_len,
full_header, data_len, data);
// Free the route + headers
free(route);
free(routing_header);
free(full_header);
// Return the total data sent
return hdr_len + data_len;
}