/* 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 validate_packet(network_interrupt_arg_t* packet, char message_type, int seq_num, int ack_num) { char* buffer = packet->buffer; if (buffer[21] == message_type && unpack_unsigned_int(&buffer[22]) == seq_num && unpack_unsigned_int(&buffer[26]) == ack_num) return 1; else 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); }
/* Print the miniroute header in a readable way for debugging */ int miniroute_print_hdr(miniroute_header_t hdr) { int i; int len; network_address_t dest; network_address_t hop; switch (hdr->routing_packet_type) { case ROUTING_ROUTE_DISCOVERY: printf("Discovery: "); break; case ROUTING_ROUTE_REPLY: printf("Reply : "); break; case ROUTING_DATA: printf("Data : "); break; default: printf("Unknown %d: ", hdr->routing_packet_type); } printf("id = %d, ", unpack_unsigned_int(hdr->id)); printf("ttl = %d, ", unpack_unsigned_int(hdr->ttl)); printf("len = %d\n", len = unpack_unsigned_int(hdr->path_len)); unpack_address(hdr->destination, dest); printf("Destination: "); network_printaddr(dest); printf("\n"); for (i = 0; i < len; ++i) { unpack_address(hdr->path[i], hop); printf("Hop %d: ", i); network_printaddr(hop); printf("\n"); } return 0; }
/* Control thread sorting received miniroute packets */ static int miniroute_control(int *arg) { network_interrupt_arg_t *intrpt; miniroute_header_t header; int ttl; network_address_t dest; while (1) { miniroute_wait_for_intrpt(&intrpt); #if MINIROUTE_DEBUG == 1 printf("Sorting Network packet.\n"); #endif header = (miniroute_header_t) intrpt->buffer; ttl = unpack_unsigned_int(header->ttl); if (intrpt->size < MINIROUTE_HDRSIZE) { free(intrpt); } else if (network_address_same(dest, hostaddr) != 1 && ttl <= 0) { free(intrpt); } else { switch (header->routing_packet_type) { case ROUTING_DATA: miniroute_process_data(intrpt); break; case ROUTING_ROUTE_DISCOVERY: miniroute_process_discovery(intrpt); break; case ROUTING_ROUTE_REPLY: miniroute_process_reply(intrpt); break; default: free(intrpt); } } } return 0; }
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_process_packet is called within the network interrupt handler. * Therefore we can safely assume that interrupts are disabled. * */ void minisocket_process_packet(void* packet) { network_interrupt_arg_t* pkt; mini_header_reliable_t pkt_hdr; unsigned int seq_num; unsigned int ack_num; minisocket_error error; network_address_t src_addr; network_address_t dst_addr; unsigned int src_port; unsigned int dst_port; minisocket_t sock; int type; int data_len; pkt = (network_interrupt_arg_t*)packet; pkt_hdr = (mini_header_reliable_t)(&pkt->buffer); //printf("in minisocket_process_packet\n"); // error checking if (pkt->size < sizeof(struct mini_header_reliable)) { free(pkt); return; } unpack_address(pkt_hdr->source_address, src_addr); src_port = unpack_unsigned_short(pkt_hdr->source_port); dst_port = unpack_unsigned_short(pkt_hdr->destination_port); unpack_address(pkt_hdr->destination_address, dst_addr); seq_num = unpack_unsigned_int(pkt_hdr->seq_number); ack_num = unpack_unsigned_int(pkt_hdr->ack_number); data_len = pkt->size - sizeof(struct mini_header_reliable); if (src_port < 0 || dst_port < 0 || src_port >= NUM_SOCKETS || dst_port >= NUM_SOCKETS || !network_compare_network_addresses(dst_addr, my_addr)){ free(pkt); return; } error = SOCKET_NOERROR; sock = sock_array[dst_port]; if (sock == NULL) { free(pkt); return; } type = pkt_hdr->message_type; //printf("socket %d with state %d\n", sock->src_port, sock->curr_state); //printf("pkt ack number is %d\n", ack_num); //printf("pkt seq number is %d\n", seq_num); //printf("my ack number is %d\n", sock->curr_ack); //printf("my seq number is %d\n", sock->curr_seq); //printf("type of msg received is %d\n", type); if (sock->curr_state != LISTEN && ( !network_compare_network_addresses(src_addr, sock->dst_addr) || src_port != sock->dst_port ) ){ if (type == MSG_SYN){ minisocket_send_ctrl_to(MSG_FIN, sock, &error, src_addr, src_port); } free(pkt); return; } switch (sock->curr_state) { case LISTEN: if (type == MSG_SYN) { sock->curr_ack = 1; semaphore_V(sock->ack_ready_sem); sock->curr_state = CONNECTING; sock->dst_port = src_port; network_address_copy(src_addr, sock->dst_addr); } free(pkt); break; case CONNECTING: if (type == MSG_ACK) { if (ack_num == sock->curr_seq) { semaphore_V(sock->ack_ready_sem); sock->curr_state = CONNECTED; } if (seq_num == sock->curr_ack+1 && data_len > 0) { queue_append(sock->pkt_q, pkt); semaphore_V(sock->pkt_ready_sem); minisocket_send_ctrl(MSG_ACK, sock, &error); sock->curr_ack++; } else { free(pkt); } } else { free(pkt); } break; case CONNECT_WAIT://TODO if (type == MSG_FIN) { sock->curr_state = CLOSE_RCV; semaphore_V(sock->ack_ready_sem);//notify blocked guy } else if (type == MSG_SYNACK) { if (ack_num == sock->curr_seq) { sock->curr_state = CONNECTED; sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error); semaphore_V(sock->ack_ready_sem); } } free(pkt); break; case MSG_WAIT: if (type == MSG_FIN){ sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error);//notify to closer sock->curr_state = CLOSE_RCV; if (sock->resend_alarm){ deregister_alarm(sock->resend_alarm); sock->resend_alarm = NULL; } sock->resend_alarm = set_alarm(RESEND_TIME_UNIT * 150, self_destruct, (void*)sock, minithread_time()); semaphore_V(sock->ack_ready_sem);//notify blocked guy } else if (type == MSG_ACK) { if (ack_num == sock->curr_seq) { //printf("got an ACK!\n"); semaphore_V(sock->ack_ready_sem); sock->curr_state = CONNECTED; } if (seq_num == sock->curr_ack+1 && data_len > 0) { //printf("got a MESSAGE!\n"); queue_append(sock->pkt_q, pkt); sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error); semaphore_V(sock->pkt_ready_sem); } else { free(pkt); } } else { free(pkt); } break; case CLOSE_SEND: if (type == MSG_ACK && ack_num == sock->curr_seq) { semaphore_V(sock->ack_ready_sem); } if (type == MSG_FIN){ sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error);//notify to closer sock->curr_state = CLOSE_RCV; if (sock->resend_alarm){ deregister_alarm(sock->resend_alarm); sock->resend_alarm = NULL; } sock->resend_alarm = set_alarm(RESEND_TIME_UNIT * 150, self_destruct, (void*)sock, minithread_time()); //minisocket_send_ctrl(MSG_ACK, sock, &error); } //free(pkt); break; case CLOSE_RCV: if (type == MSG_FIN && ack_num == sock->curr_seq) { minisocket_send_ctrl(MSG_ACK, sock, &error); //semaphore_V(sock->ack_ready_sem); } free(pkt); break; case CONNECTED: if (type == MSG_FIN){ sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error);//notify to closer sock->curr_state = CLOSE_RCV; if (sock->resend_alarm){ deregister_alarm(sock->resend_alarm); sock->resend_alarm = NULL; } sock->resend_alarm = set_alarm(RESEND_TIME_UNIT * 150, self_destruct, (void*)sock, minithread_time()); } if (type == MSG_ACK) { if (ack_num == sock->curr_seq) { //semaphore_V(sock->ack_ready_sem); sock->curr_state = CONNECTED; } if (seq_num == sock->curr_ack+1 && data_len > 0) { //printf("got some DATA\n"); queue_append(sock->pkt_q, pkt); sock->curr_ack++; minisocket_send_ctrl(MSG_ACK, sock, &error); semaphore_V(sock->pkt_ready_sem); //printf("got data, no seg fault\n"); } else if (seq_num == sock->curr_ack && data_len > 0){ minisocket_send_ctrl(MSG_ACK, sock, &error); } else { free(pkt); } } else { free(pkt); } break; case EXIT: default: free(pkt); break; } }
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; // Check the protocol switch (arg->buffer[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) &arg->buffer; 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); 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) arg->buffer; 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) { 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) { set_interrupt_level(prev_level); return; } if (socket->status == TCP_PORT_CLOSING || socket->waiting == TCP_PORT_WAITING_CLOSE) { 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); } 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; } 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); 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) { 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) { 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; } // Restore the interrupt level set_interrupt_level(prev_level); return; }
/* 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) { //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; }
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* 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); } } }
/* 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; }
void minisocket_handle_tcp_packet(network_interrupt_arg_t *arg) { mini_header_reliable_t *header = (mini_header_reliable_t *) (arg->buffer); int port = unpack_unsigned_short(header->destination_port); if (port < MIN_SERVER_PORT || port > MAX_CLIENT_PORT || !ports[port]) { free(arg); return; } if (ports[port]->socket_state == INITIAL || ports[port]->socket_state == CLOSED) { free(arg); return; } if (ports[port]->socket_state != OPEN) { // handled in handshake queue_append(ports[port]->data, arg); semaphore_V(ports[port]->data_ready); return; } minisocket_error s_error; network_address_t saddr; unpack_address(header->source_address, saddr); int sport = unpack_unsigned_short(header->source_port); if (!network_compare_network_addresses(ports[port]->remote_addr, saddr) || ports[port]->remote_port != sport) { if(header->message_type -'0' == MSG_SYN) { send_control_message(MSG_FIN, sport, saddr, port, 0, 0, &s_error); } free(arg); return; } //If the message is of type SYNACK and from the same client if (header->message_type - '0' == MSG_SYNACK) { send_control_message(MSG_ACK, sport, saddr, port, 0, 0, &s_error); free(arg); return; } //If the message is of type FIN if (header->message_type - '0' == MSG_FIN) { ports[port]->ack_number += 1; send_control_message(MSG_ACK, sport, saddr, port, ports[port]->seq_number, ports[port]->ack_number, &s_error); ports[port]->socket_state = CLOSING; int count = semaphore_get_count(ports[port]->data_ready); while (count < 0) { semaphore_V(ports[port]->data_ready); count++; } register_alarm(15000, (alarm_handler_t) minisocket_close, ports[port]); //minisocket_free(ports[port]); free(arg); return; } //If the message is of type ACK from the same client if (header->message_type - '0' == MSG_ACK) { unsigned int ack_no = unpack_unsigned_int(header->ack_number); int packet_size = arg->size - sizeof(mini_header_reliable_t); minisocket_error s_error; //If it's a correct acknowledgement of the sent data, enqueue it and V the wait for ack semaphore if (ack_no == ports[port]->seq_number/* + MAX_NETWORK_PKT_SIZE - sizeof(mini_header_reliable_t) + 1*/) { if (packet_size != 0) { queue_append(ports[port]->data, arg); semaphore_V(ports[port]->data_ready); ports[port]->ack_number += packet_size; send_control_message(MSG_ACK, sport, saddr, port, ports[port]->seq_number, ports[port]->ack_number, &s_error); } if (ports[port]->ack_flag == 0) { ports[port]->ack_flag = 1; semaphore_V(ports[port]->wait_for_ack); } return; } else { free(arg); return; } } }
int minisocket_receive(minisocket_t *socket, char *msg, int max_len, minisocket_error *error) { if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) { *error=SOCKET_RECEIVEERROR; return 0; } if (socket->socket_state != OPEN || !msg) { *error = SOCKET_INVALIDPARAMS; return -1; } if(max_len == 0) { *error = SOCKET_NOERROR; return 0; } semaphore_P(socket->send_receive_mutex); semaphore_P(socket->data_ready); if (socket->socket_state == CLOSED || socket->socket_state == CLOSING) { *error=SOCKET_RECEIVEERROR; return 0; } network_interrupt_arg_t *arg; queue_dequeue(socket->data, (void **) &arg); int msg_len = arg->size - sizeof(mini_header_reliable_t); assert(msg_len > 0); int copy_len = ( msg_len > max_len) ? max_len : msg_len; for(int i=0;i<copy_len;i++) { msg[i] = arg->buffer[sizeof(mini_header_reliable_t) + i]; } //If the packet contained more data than the buffer could take, then enqueue the packet with the remaining message again if(copy_len > max_len) { mini_header_reliable_t *h = (mini_header_reliable_t *) malloc(sizeof(mini_header_reliable_t)); if(!h) { *error = SOCKET_OUTOFMEMORY; semaphore_V(socket->send_receive_mutex); return -1; } mini_header_reliable_t *header = (mini_header_reliable_t *) arg->buffer; //Update the sequence number in the header unsigned int seq_no = unpack_unsigned_int(header->seq_number); pack_unsigned_int(header->seq_number, seq_no + max_len); //Copy the remaining message to the start of the message space in the buffer memcpy(arg->buffer + sizeof(mini_header_reliable_t), arg->buffer + sizeof(mini_header_reliable_t) + max_len, msg_len - max_len); //Set the packet size to its correct length arg->size = msg_len + sizeof(mini_header_reliable_t); //Prepend the packet in the data queue queue_prepend(socket->data, &arg); } semaphore_V(socket->send_receive_mutex); return copy_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; }