static mini_header_reliable_t *create_control_header(int msg_type, unsigned int dest_port,
network_address_t dest_addr, unsigned int src_port,
unsigned int seq, unsigned int ack)
{
mini_header_reliable_t *header = (mini_header_reliable_t *) malloc(sizeof(mini_header_reliable_t));
if (!header) {
return NULL;
}
header->protocol = PROTOCOL_MINISTREAM + '0';
network_address_t local_addr;
network_address_copy(local_host, local_addr);
//network_get_my_address(local_addr);
pack_address(header->source_address, local_addr);
pack_unsigned_short(header->source_port, src_port);
header->message_type = msg_type + '0';
pack_address(header->destination_address, dest_addr);
pack_unsigned_short(header->destination_port, dest_port);
pack_unsigned_int(header->seq_number, seq);
pack_unsigned_int(header->ack_number, ack);
return header;
}
/* Creates a bound port for use in sending packets. The two parameters, addr and
* remote_unbound_port_number together specify the remote's listening endpoint.
* This function should assign bound port numbers incrementally between the range
* 32768 to 65535. Port numbers should not be reused even if they have been destroyed,
* unless an overflow occurs (ie. going over the 65535 limit) in which case you should
* wrap around to 32768 again, incrementally assigning port numbers that are not
* currently in use.
*/
miniport_t
miniport_create_bound(network_address_t addr, int remote_unbound_port_number)
{
unsigned short start;
miniport_t new_port;
semaphore_P(bound_ports_lock);
start = curr_bound_index;
while (miniport_array[curr_bound_index] != NULL){
curr_bound_index += 1;
if (curr_bound_index >= MAX_PORT_NUM){
curr_bound_index = BOUND_PORT_START;
}
if (curr_bound_index == start){ //bound port array full
semaphore_V(bound_ports_lock);
return NULL;
}
}
new_port = (miniport_t)malloc(sizeof(struct miniport));
if (new_port == NULL) {
semaphore_V(bound_ports_lock);
return NULL;
}
new_port->p_type = BOUND_PORT;
new_port->p_num = curr_bound_index;
new_port->u.bound.dest_num = remote_unbound_port_number;
network_address_copy(addr, new_port->u.bound.dest_addr);
miniport_array[curr_bound_index] = new_port;
curr_bound_index += 1; //point to next slot
if (curr_bound_index >= MAX_PORT_NUM){
curr_bound_index = BOUND_PORT_START;
}
semaphore_V(bound_ports_lock);
return new_port;
}
/* 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;
}
/* Reverse a route */
network_address_t* miniroute_reverse_raw_path(routing_header_t header, int path_len)
{
network_address_t unpacked_addr;
int i = 0;
network_address_t* reversed_path = (network_address_t*) malloc(path_len * sizeof(network_address_t));
if (reversed_path == NULL)
return NULL;
for (i = 0; i < path_len; i++)
{
unpack_address(header->path[i], unpacked_addr);
network_address_copy(unpacked_addr, reversed_path[path_len-1-i]);
}
return reversed_path;
}
/* Creates a bound port for use in sending packets. The two parameters, addr and
* remote_unbound_port_number together specify the remote's listening endpoint.
* This function should assign bound port numbers incrementally between the range
* 32768 to 65535. Port numbers should not be reused even if they have been destroyed,
* unless an overflow occurs (ie. going over the 65535 limit) in which case you should
* wrap around to 32768 again, incrementally assigning port numbers that are not
* currently in use.
*/
miniport_t
miniport_create_bound(network_address_t addr, int remote_unbound_port_number)
{
int num;
semaphore_P(port_mutex);
num = miniport_get_boundedport_num();
if (num < MIN_BOUNDED || num > MAX_BOUNDED) {
semaphore_V(port_mutex);
return NULL;
}
if ((port[num] = malloc(sizeof(struct miniport))) != NULL) {
port[num]->type = BOUNDED;
port[num]->num = num;
network_address_copy(addr, port[num]->bound.addr);
port[num]->bound.remote = remote_unbound_port_number;
}
semaphore_V(port_mutex);
return port[num];
}
/*
* 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.
* Return -1 if len is larger then the maximum package size.
*/
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 dest;
int sent;
if (NULL == local_unbound_port || NULL == local_bound_port
|| UNBOUNDED != local_unbound_port->type
|| BOUNDED != local_bound_port->type
|| NULL == msg || len < 0 || len > MINIMSG_MAX_MSG_SIZE)
return -1;
minimsg_packhdr(&hdr, local_unbound_port, local_bound_port);
network_address_copy(local_bound_port->bound.addr, dest);
sent = miniroute_send_pkt(dest, MINIMSG_HDRSIZE, (char*)&hdr, len, msg);
return sent - MINIMSG_HDRSIZE < 0 ? -1 : sent - MINIMSG_HDRSIZE;
}
/* Creates a bound port for use in sending packets. The two parameters, addr and
* remote_unbound_port_number together specify the remote's listening endpoint.
* This function should assign bound port numbers incrementally between the range
* 32768 to 65535. Port numbers should not be reused even if they have been destroyed,
* unless an overflow occurs (ie. going over the 65535 limit) in which case you should
* wrap around to 32768 again, incrementally assigning port numbers that are not
* currently in use.
*/
miniport_t miniport_create_bound(network_address_t addr, int remote_unbound_port_number) {
miniport_t bound_port;
/*// Ensure port_number is valid for this bound miniport
if (port_number < BOUND_MIN_PORT_NUM || port_number > BOUND_MAX_PORT_NUM) {
fprintf(stderr, "ERROR: miniport_create_bound() passed a bad port number\n");
return NULL;
}*/
//Check validity of addr
semaphore_P(msgmutex);
semaphore_P(bound_ports_free); // Wait for a free bound port
// Find next open bound port (guaranteed to exist by P() on bound_ports_free above)
while (ports[bound_ctr] != NULL) {
// bount_ctr = (bound_ctr + 1 - BOUND_MIN_PORT_NUM) % (BOUND_MAX_PORT_NUM - BOUND_MIN_PORT_NUM + 1) + BOUND_MIN_PORT_NUM;
bound_ctr = (bound_ctr + 1 > BOUND_MAX_PORT_NUM) ? BOUND_MIN_PORT_NUM : (bound_ctr + 1);
}
// Allocate new bound port
bound_port = malloc(sizeof(struct miniport));
if (bound_port == NULL) {
fprintf(stderr, "ERROR: miniport_create_bound() failed to malloc new miniport\n");
semaphore_V(msgmutex);
return NULL;
}
bound_port->port_type = BOUND;
bound_port->port_num = bound_ctr;
network_address_copy(addr, bound_port->u.bound.remote_address);
bound_port->u.bound.remote_unbound_port = remote_unbound_port_number;
ports[bound_ctr] = bound_port;
semaphore_V(msgmutex);
return ports[bound_ctr];
}
/* 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;
}
/* Initiate the communication with a remote site. When communication is
* established create a minisocket through which the communication can be made
* from now on.
*
* The first argument is the network address of the remote machine.
*
* The argument "port" is the port number on the remote machine to which the
* connection is made. The port number of the local machine is one of the free
* port numbers.
*
* Return value: the minisocket_t created, otherwise NULL with the errorcode
* stored in the "error" variable.
*/
minisocket_t minisocket_client_create(network_address_t addr, int port, minisocket_error *error)
{
minisocket_t new_sock;
interrupt_level_t l;
resend_arg* resend_alarm_arg;
unsigned short start;
char tmp;
//check valid portnum
if (port < 0 || port >= CLIENT_START) {
*error = SOCKET_INVALIDPARAMS;
return NULL;
}
semaphore_P(client_lock);
start = curr_client_idx;
while (sock_array[curr_client_idx] != NULL){
curr_client_idx++;
if (curr_client_idx >= NUM_SOCKETS){
curr_client_idx = CLIENT_START;
}
if (curr_client_idx == start){ // client sockets full
semaphore_V(client_lock);
*error = SOCKET_NOMOREPORTS;
return NULL;
}
}
new_sock = (minisocket_t)malloc(sizeof(struct minisocket));
if (!new_sock){
semaphore_V(client_lock);
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
new_sock->pkt_ready_sem = semaphore_create();
if (!(new_sock->pkt_ready_sem)){
semaphore_V(client_lock);
free(new_sock);
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
new_sock->pkt_q = queue_new();
if (!(new_sock->pkt_q)){
semaphore_V(client_lock);
semaphore_destroy(new_sock->pkt_ready_sem);
free(new_sock);
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
new_sock->sock_lock = semaphore_create();
if (!(new_sock->sock_lock)){
semaphore_V(client_lock);
semaphore_destroy(new_sock->pkt_ready_sem);
queue_free(new_sock->pkt_q);
free(new_sock);
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
new_sock->ack_ready_sem = semaphore_create();
if (!(new_sock->ack_ready_sem)){
semaphore_V(client_lock);
semaphore_destroy(new_sock->pkt_ready_sem);
queue_free(new_sock->pkt_q);
semaphore_destroy(new_sock->sock_lock);
free(new_sock);
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
semaphore_initialize(new_sock->pkt_ready_sem, 0);
semaphore_initialize(new_sock->ack_ready_sem, 0);
semaphore_initialize(new_sock->sock_lock, 1);
new_sock->curr_state = CONNECT_WAIT;
new_sock->try_count = 0;
new_sock->curr_ack = 0;
new_sock->curr_seq = 1;
new_sock->resend_alarm = NULL; //no alarm set
new_sock->src_port = curr_client_idx;
new_sock->dst_port = port;
network_address_copy(addr, new_sock->dst_addr);
sock_array[curr_client_idx] = new_sock;
semaphore_V(client_lock);
l = set_interrupt_level(DISABLED);
minisocket_send_ctrl(MSG_SYN, new_sock, error);
resend_alarm_arg = (resend_arg*)calloc(1, sizeof(resend_arg));
resend_alarm_arg->sock = new_sock;
resend_alarm_arg->msg_type = MSG_SYN;
resend_alarm_arg->data_len = 0;
resend_alarm_arg->data = &tmp; //placeholder
resend_alarm_arg->error = error;
new_sock->resend_alarm = set_alarm(RESEND_TIME_UNIT, minisocket_resend, resend_alarm_arg, minithread_time());
set_interrupt_level(l);
semaphore_P(new_sock->ack_ready_sem);
l = set_interrupt_level(DISABLED);
switch(new_sock->curr_state) {
case CONNECTED: //we are connected
// must have gotten a MSG_SYNACK
new_sock->curr_state = CONNECTED;
new_sock->try_count = 0;
if (new_sock->resend_alarm){
deregister_alarm(new_sock->resend_alarm);
}
new_sock->resend_alarm = NULL;
*error = SOCKET_NOERROR;
set_interrupt_level(l);
break;
case CLOSE_RCV:
*error = SOCKET_BUSY;
minisocket_destroy(new_sock, error);
if (new_sock->resend_alarm){
deregister_alarm(new_sock->resend_alarm);
}
new_sock->resend_alarm = NULL;
*error = SOCKET_BUSY;
set_interrupt_level(l);
new_sock = NULL;
break;
default:
// error
*error = SOCKET_NOSERVER;
minisocket_destroy(new_sock, error);
set_interrupt_level(l);
new_sock = NULL;
break;
}
free(resend_alarm_arg);
return new_sock;
}
/* 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;
}
}
minisocket_t* minisocket_server_create(int port, minisocket_error *error)
{
if (port < MIN_SERVER_PORT || port > MAX_SERVER_PORT) {
*error = SOCKET_INVALIDPARAMS;
return NULL;
}
if (ports[port]) {
*error = SOCKET_PORTINUSE;
return NULL;
}
minisocket_t *new_socket = (minisocket_t *) malloc(sizeof(minisocket_t));
if (!new_socket) {
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
// Initialize new socket
new_socket->socket_state = INITIAL;
semaphore_P(ports_mutex);
ports[port] = new_socket;
semaphore_V(ports_mutex);
new_socket->socket_type = 's';
new_socket->local_port = port;
network_address_copy(local_host, new_socket->local_addr);
new_socket->data = queue_new();
new_socket->data_ready = semaphore_create();
new_socket->ack_flag = 0;
new_socket->wait_for_ack = semaphore_create();
new_socket->send_receive_mutex = semaphore_create();
semaphore_initialize(new_socket->data_ready, 0);
semaphore_initialize(new_socket->wait_for_ack, 0);
semaphore_initialize(new_socket->send_receive_mutex, 1);
interrupt_level_t old_level;
while (1) {
new_socket->seq_number = 0;
new_socket->ack_number = 0;
new_socket->remote_port = -1;
new_socket->remote_addr[0] = 0;
new_socket->remote_addr[1] = 0;
new_socket->socket_state = WAITING_SYN;
// receiving SYN
while (1) {
semaphore_P(new_socket->data_ready);
network_interrupt_arg_t *arg = NULL;
queue_dequeue(new_socket->data, (void **) &arg);
mini_header_reliable_t *header = (mini_header_reliable_t *) arg->buffer;
if (header->message_type -'0'== MSG_SYN) {
unpack_address(header->source_address, new_socket->remote_addr);
new_socket->remote_port = unpack_unsigned_short(header->source_port);
new_socket->socket_state = WAITING_ACK;
new_socket->seq_number = 0;
new_socket->ack_number = 1;
break;
}
else {
free(arg);
}
}
minisocket_error s_error;
int wait_val = 100;
while (wait_val <= 12800) {
send_control_message(MSG_SYNACK, new_socket->remote_port, new_socket->remote_addr, new_socket->local_port, 0 , 1, &s_error);
new_socket->seq_number = 1;
new_socket->ack_number = 1;
if (s_error == SOCKET_OUTOFMEMORY) {
minisocket_free(new_socket);
semaphore_P(ports_mutex);
ports[new_socket->local_port] = NULL;
semaphore_V(ports_mutex);
*error = s_error;
return NULL;
}
alarm_id a = register_alarm(wait_val, (alarm_handler_t) semaphore_V, new_socket->data_ready);
semaphore_P(new_socket->data_ready);
old_level = set_interrupt_level(DISABLED);
if (queue_length(new_socket->data)) {
deregister_alarm(a);
}
set_interrupt_level(old_level);
if (!queue_length(new_socket->data)) {
wait_val *= 2;
continue;
}
network_interrupt_arg_t *arg = NULL;
queue_dequeue(new_socket->data, (void **) &arg);
mini_header_reliable_t *header = (mini_header_reliable_t *) arg->buffer;
network_address_t saddr;
unpack_address(header->source_address, saddr);
int sport = unpack_unsigned_short(header->source_port);
if (header->message_type - '0' == MSG_SYN) {
if (new_socket->remote_port == sport && network_compare_network_addresses(new_socket->remote_addr, saddr)) {
continue;
}
send_control_message(MSG_FIN, sport, saddr, new_socket->local_port, 0, 0, &s_error);
}
if (header->message_type - '0' == MSG_ACK) {
if (new_socket->remote_port == sport && network_compare_network_addresses(new_socket->remote_addr, saddr)) {
network_interrupt_arg_t *packet = NULL;
while (queue_dequeue(new_socket->data, (void **)&packet) != -1) {
free(packet);
}
semaphore_initialize(new_socket->data_ready, 0);
new_socket->socket_state = OPEN;
new_socket->seq_number = 1;
new_socket->ack_number = 2;
return new_socket;
}
}
free (arg);
}
}
return NULL;
}
minisocket_t* minisocket_client_create(const network_address_t addr, int port, minisocket_error *error)
{
if (!addr || port < MIN_SERVER_PORT || port > MAX_SERVER_PORT) {
*error = SOCKET_INVALIDPARAMS;
return NULL;
}
int port_val = -1;
// CHECK what n_client_ports does
if (!ports[n_client_ports]) {
port_val = n_client_ports;
}
else {
for (int i = MIN_CLIENT_PORT; i <= MAX_CLIENT_PORT; i++) {
if (!ports[i]) {
port_val = i;
break;
}
}
}
n_client_ports = port_val + 1;
if (n_client_ports > MAX_CLIENT_PORT) {
n_client_ports = 0;
}
if (port_val == -1) {
*error = SOCKET_NOMOREPORTS;
return NULL;
}
minisocket_t *new_socket = (minisocket_t *) malloc(sizeof(minisocket_t));
if (!new_socket) {
*error = SOCKET_OUTOFMEMORY;
return NULL;
}
new_socket->socket_state = INITIAL;
semaphore_P(ports_mutex);
ports[port_val] = new_socket;
semaphore_V(ports_mutex);
new_socket->socket_type = 'c';
network_address_copy(local_host, new_socket->local_addr);
//network_get_my_address(new_socket->local_addr);
new_socket->local_port = port_val;
network_address_copy(addr, new_socket->remote_addr);
new_socket->remote_port = port;
new_socket->data = queue_new();
new_socket->data_ready = semaphore_create();
new_socket->wait_for_ack = semaphore_create();
new_socket->send_receive_mutex = semaphore_create();
semaphore_initialize(new_socket->data_ready, 0);
semaphore_initialize(new_socket->wait_for_ack, 0);
semaphore_initialize(new_socket->send_receive_mutex, 1);
new_socket->socket_state = WAITING_SYNACK;
minisocket_error s_error;
int wait_val = 100;
interrupt_level_t old_level;
while (wait_val <= 12800) {
send_control_message(MSG_SYN, new_socket->remote_port, new_socket->remote_addr, new_socket->local_port, 0, 0, &s_error);
new_socket->seq_number = 1;
new_socket->ack_number = 0;
if (s_error == SOCKET_OUTOFMEMORY) {
minisocket_free(new_socket);
semaphore_P(ports_mutex);
ports[new_socket->local_port] = NULL;
semaphore_V(ports_mutex);
*error = s_error;
return NULL;
}
alarm_id a = register_alarm(wait_val, (alarm_handler_t) semaphore_V, new_socket->data_ready);
semaphore_P(new_socket->data_ready);
old_level = set_interrupt_level(DISABLED);
if (queue_length(new_socket->data)) {
deregister_alarm(a);
}
set_interrupt_level(old_level);
if (!queue_length(new_socket->data)) {
wait_val *= 2;
continue;
}
network_interrupt_arg_t *arg = NULL;
queue_dequeue(new_socket->data, (void **) &arg);
mini_header_reliable_t *header = (mini_header_reliable_t *) arg->buffer;
network_address_t saddr;
unpack_address(header->source_address, saddr);
int sport = unpack_unsigned_short(header->source_port);
if (sport == new_socket->remote_port && network_compare_network_addresses(saddr, new_socket->remote_addr)) {
if (header->message_type - '0' == MSG_SYNACK) {
new_socket->seq_number = 1;
new_socket->ack_number = 1;
send_control_message(MSG_ACK, new_socket->remote_port, new_socket->remote_addr, new_socket->local_port, 1, 1, &s_error);
if (s_error == SOCKET_OUTOFMEMORY) {
minisocket_free(new_socket);
semaphore_P(ports_mutex);
ports[new_socket->local_port] = NULL;
semaphore_V(ports_mutex);
*error = s_error;
return NULL;
}
network_interrupt_arg_t *packet = NULL;
while (queue_dequeue(new_socket->data, (void **)&packet) != -1) {
free(packet);
}
semaphore_initialize(new_socket->data_ready, 0);
new_socket->socket_state = OPEN;
new_socket->seq_number = 2;
new_socket->ack_number = 1;
return new_socket;
}
if (header->message_type -'0' == MSG_FIN) {
minisocket_free(new_socket);
return NULL;
}
}
free(arg);
}
minisocket_free(new_socket);
return NULL;
}
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;
}
/*
* Initiate the communication with a remote site. When communication is
* established create a minisocket through which the communication can be made
* from now on.
*
* The first argument is the network address of the remote machine.
*
* The argument "port" is the port number on the remote machine to which the
* connection is made. The port number of the local machine is one of the free
* port numbers.
*
* Return value: the minisocket_t created, otherwise NULL with the errorcode
* stored in the "error" variable.
*/
minisocket_t minisocket_client_create(network_address_t addr, int port, minisocket_error *error)
{
int port_number;
int num_client_ports = TCP_MAX_CLIENT - TCP_MIN_CLIENT + 1;
int adjusted_port;
int found_port = 0;
int i;
int transmit_ret;
minisocket_t minisocket;
if (error == NULL)
{
return NULL;
}
// Synchornize access to the client port range of the minisocket pool
semaphore_P(client_sem);
// Find a free client port to use
if (client_wrapped == 0)
{
// If we haven't wrapped around yet, just pick the next port
port_number = current_client_port++;
// Check if we need to wrap around
if (current_client_port > TCP_MAX_CLIENT)
{
client_wrapped = 1;
current_client_port = TCP_MIN_CLIENT;
}
}
else
{
for (i = 0; i < num_client_ports; i++)
{
// Sorry this goes over 80 characters, but it's easier to see on one line
adjusted_port = (((current_client_port - TCP_MIN_CLIENT)+i) % num_client_ports) + TCP_MIN_CLIENT;
if (minisockets[adjusted_port] == NULL)
{
current_client_port = adjusted_port;
found_port = 1;
break;
}
}
// If we coulnd't find a port, return NULL
if (found_port == 0)
{
*error = SOCKET_NOMOREPORTS;
semaphore_V(client_sem);
return NULL;
}
// Set the port number
port_number = current_client_port++;
}
// Create the socket
minisocket = minisocket_setup_socket(port_number);
if (minisocket == NULL)
{
*error = SOCKET_OUTOFMEMORY;
semaphore_V(client_sem);
return NULL;
}
// Set the port type and client variables
minisocket->port_type = TCP_PORT_TYPE_CLIENT;
network_address_copy(addr, minisocket->dst_addr);
minisocket->dst_port = port;
// Set the port in the array
minisockets[port_number] = minisocket;
// Prepare to send a SYN and connect
minisocket->status = TCP_PORT_CONNECTING;
// Release the sem as soon as possible
semaphore_V(client_sem);
// Send the SYN - incr the seq # too, and do retransmission sequence pending SYNACK
transmit_ret = transmit_packet(minisocket, addr, port, 1, MSG_SYN, 0, NULL, error);
// Check if we got a FIN - which means the server is busy with another client
if (minisocket->status == TCP_PORT_COULDNT_CONNECT)
{
// The packet process thread will make the status this value if we were
// connecting and got a FIN
minisockets[port] = NULL;
free(minisocket);
*error = SOCKET_BUSY;
return NULL;
}
// Check if the server didn't respond
if (transmit_ret == -1)
{
// The error code is set by transmit_packet(), so just clean up & return
minisockets[port] = NULL;
free(minisocket);
return NULL;
}
minisocket->status = TCP_PORT_CONNECTED;
*error = SOCKET_NOERROR;
return minisocket;
}
/*
* Initiate the communication with a remote site. When communication is
* established create a minisocket through which the communication can be made
* from now on.
*
* The first argument is the network address of the remote machine.
*
* The argument "port" is the port number on the remote machine to which the
* connection is made. The port number of the local machine is one of the free
* port numbers.
*
* Return value: the minisocket_t created, otherwise NULL with the errorcode
* stored in the "error" variable.
*/
minisocket_t minisocket_client_create(network_address_t addr, int port, minisocket_error *error) {
minisocket_t socket;
// char* buffer;
int local_port = CLIENT_MIN_PORT;
// int synack_done;
int /*send_attempts, timeout,*/ received_SYNACK;
// network_address_t dest, my_address;
mini_header_reliable_t hdr; // Header for sending MSG_SYNACK message
// network_interrupt_arg_t* packet = NULL;
// semaphore_P(skt_mutex);
// Check for available ports
if (used_client_ports >= NUM_CLIENT_PORTS) {
fprintf(stderr, "ERROR: minisocket_client_create() unable to execute since no available ports exist\n");
*error = SOCKET_NOMOREPORTS;
// semaphore_V(skt_mutex);
return NULL;
}
// Check for valid arguments
if (addr == NULL) {
fprintf(stderr, "ERROR: minisocket_client_create() passed NULL network_address_t\n");
*error = SOCKET_INVALIDPARAMS;
// semaphore_V(skt_mutex);
return NULL;
}
if (port < SERVER_MIN_PORT || port > SERVER_MAX_PORT) {
fprintf(stderr, "ERROR: minisocket_client_create() passed invalid remote port number\n");
*error = SOCKET_INVALIDPARAMS;
// semaphore_V(skt_mutex);
return NULL;
}
if (sockets[local_port] != NULL) {
fprintf(stderr, "ERROR: minisocket_client_create() passed port already in use\n");
*error = SOCKET_PORTINUSE;
// semaphore_V(skt_mutex);
return NULL;
}
// Allocate new minisocket
socket = malloc(sizeof(struct minisocket));
if (socket == NULL) { // Could not allocate minisocket
fprintf(stderr, "ERROR: minisocket_client_create() failed to malloc new minisocket\n");
*error = SOCKET_OUTOFMEMORY;
// semaphore_V(skt_mutex);
return NULL;
}
// Find next unused local port (guaranteed to exist due to counter and verification)
while (local_port <= CLIENT_MAX_PORT && sockets[local_port] != NULL) {
local_port++;
}
if (sockets[local_port] != NULL) {
fprintf(stderr, "ERROR: minisocket_client_create() ran out of available ports unexpectedly\n");
*error = SOCKET_NOMOREPORTS;
// semaphore_V(skt_mutex);
return NULL;
}
// Set fields in minisocket
socket->active = 1;
socket->local_port = local_port;
socket->remote_port = port;
network_address_copy(addr, socket->dest_address);
socket->datagrams_ready = semaphore_create();
semaphore_initialize(socket->datagrams_ready, 0);
socket->sending = semaphore_create();
semaphore_initialize(socket->sending, 1);
socket->receiving = semaphore_create();
semaphore_initialize(socket->receiving, 1);
socket->timeout = semaphore_create();
semaphore_initialize(socket->timeout, 0);
socket->wait_syn = semaphore_create();
semaphore_initialize(socket->wait_syn, 0);
socket->incoming_data = queue_new();
socket->seqnum = 0;
socket->acknum = 0;
socket->alarm = NULL;
sockets[local_port] = socket; // Add socket to socket ports array
used_client_ports++; // Increment client-ports-in-use counter
// Send MSG_SYN packet to server
// Wait timeout, if no response, repeat 7 more times (7 retries)
// Allocate new header for SYN packet
hdr = malloc(sizeof(struct mini_header_reliable));
if (hdr == NULL) { // Could not allocate header
fprintf(stderr, "ERROR: minisocket_client_create() failed to malloc new mini_header_reliable\n");
*error = SOCKET_OUTOFMEMORY;
// semaphore_V(skt_mutex);
return NULL;
}
socket->seqnum++;
// Assemble packet header
set_header(socket, hdr, MSG_SYN);
// Send SYN packet, expect SYNACK packet
received_SYNACK = retransmit_packet(socket, (char*) hdr, 0, NULL, error);
// semaphore_V(skt_mutex);
if (received_SYNACK) {
*error = SOCKET_NOERROR;
return socket;
} else {
socket->active = 0;
*error = SOCKET_RECEIVEERROR;
return NULL;
}
}
network_socket *self_connect(network_mysqld_con *con, network_backend_t *backend, GHashTable *pwd_table) {
/*make sure that the max conn for the backend is no more than the config number
*when max_conn_for_a_backend is no more than 0, there is no limitation for max connection for a backend;
* */
if (con->srv->max_conn_for_a_backend > 0 && backend->connected_clients >= con->srv->max_conn_for_a_backend) {
g_critical("%s.%d: self_connect:%08x's connected_clients is %d, which are too many!",__FILE__, __LINE__, backend, backend->connected_clients);
return NULL;
}
//1. connect DB
network_socket *sock = network_socket_new();
network_address_copy(sock->dst, backend->addr);
if (-1 == (sock->fd = socket(sock->dst->addr.common.sa_family, sock->socket_type, 0))) {
g_critical("%s.%d: socket(%s) failed: %s (%d)", __FILE__, __LINE__, sock->dst->name->str, g_strerror(errno), errno);
network_socket_free(sock);
return NULL;
}
if (-1 == (connect(sock->fd, &sock->dst->addr.common, sock->dst->len))) {
g_message("%s.%d: connecting to backend (%s) failed, marking it as down for ...", __FILE__, __LINE__, sock->dst->name->str);
network_socket_free(sock);
if (backend->state != BACKEND_STATE_OFFLINE) backend->state = BACKEND_STATE_DOWN;
return NULL;
}
//2. read handshake，重点是获取20个字节的随机串
off_t to_read = NET_HEADER_SIZE;
guint offset = 0;
guchar header[NET_HEADER_SIZE];
while (to_read > 0) {
gssize len = recv(sock->fd, header + offset, to_read, 0);
if (len == -1 || len == 0) {
network_socket_free(sock);
return NULL;
}
offset += len;
to_read -= len;
}
to_read = header[0] + (header[1] << 8) + (header[2] << 16);
offset = 0;
GString *data = g_string_sized_new(to_read);
while (to_read > 0) {
gssize len = recv(sock->fd, data->str + offset, to_read, 0);
if (len == -1 || len == 0) {
network_socket_free(sock);
g_string_free(data, TRUE);
return NULL;
}
offset += len;
to_read -= len;
}
data->len = offset;
network_packet packet;
packet.data = data;
packet.offset = 0;
network_mysqld_auth_challenge *challenge = network_mysqld_auth_challenge_new();
network_mysqld_proto_get_auth_challenge(&packet, challenge);
//3. 生成response
GString *response = g_string_sized_new(20);
GString *hashed_password = g_hash_table_lookup(pwd_table, con->client->response->username->str);
if (hashed_password) {
network_mysqld_proto_password_scramble(response, S(challenge->challenge), S(hashed_password));
} else {
network_socket_free(sock);
g_string_free(data, TRUE);
network_mysqld_auth_challenge_free(challenge);
g_string_free(response, TRUE);
return NULL;
}
//4. send auth
off_t to_write = 58 + con->client->response->username->len;
offset = 0;
g_string_truncate(data, 0);
char tmp[] = {to_write - 4, 0, 0, 1, 0x85, 0xa6, 3, 0, 0, 0, 0, 1, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
g_string_append_len(data, tmp, 36);
g_string_append_len(data, con->client->response->username->str, con->client->response->username->len);
g_string_append_len(data, "\0\x14", 2);
g_string_append_len(data, response->str, 20);
g_string_free(response, TRUE);
while (to_write > 0) {
gssize len = send(sock->fd, data->str + offset, to_write, 0);
if (len == -1) {
network_socket_free(sock);
g_string_free(data, TRUE);
network_mysqld_auth_challenge_free(challenge);
return NULL;
}
offset += len;
to_write -= len;
}
//5. read auth result
to_read = NET_HEADER_SIZE;
offset = 0;
while (to_read > 0) {
gssize len = recv(sock->fd, header + offset, to_read, 0);
if (len == -1 || len == 0) {
network_socket_free(sock);
g_string_free(data, TRUE);
network_mysqld_auth_challenge_free(challenge);
return NULL;
}
offset += len;
to_read -= len;
}
to_read = header[0] + (header[1] << 8) + (header[2] << 16);
offset = 0;
g_string_truncate(data, 0);
g_string_set_size(data, to_read);
while (to_read > 0) {
gssize len = recv(sock->fd, data->str + offset, to_read, 0);
if (len == -1 || len == 0) {
network_socket_free(sock);
g_string_free(data, TRUE);
network_mysqld_auth_challenge_free(challenge);
return NULL;
}
offset += len;
to_read -= len;
}
data->len = offset;
if (data->str[0] != MYSQLD_PACKET_OK) {
network_socket_free(sock);
g_string_free(data, TRUE);
network_mysqld_auth_challenge_free(challenge);
return NULL;
}
g_string_free(data, TRUE);
//6. set non-block
network_socket_set_non_blocking(sock);
network_socket_connect_setopts(sock); //此句是否需要？是否应该放在第1步末尾？
sock->challenge = challenge;
sock->response = network_mysqld_auth_response_copy(con->client->response);
g_atomic_int_inc(&backend->connected_clients);
return sock;
}
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;
}
static
gint
admin_reload_backends(
network_mysqld_con* con,
GPtrArray* backend_addr_str_array,
gint fail_flag
)
{
chassis* srv;
network_backends_t* backends;
GPtrArray* cons;
gchar* s;
gchar* new_backend_addr;
guint i;
//gchar ip_address[MAX_IP_PORT_STRING_LEN + 1];
admin_network_addr_t* addr;
GPtrArray* addr_array;
gint ret = EC_ADMIN_RELOAD_SUCCESS;
gboolean all_same_flag = 1;
guint server_cnt = 0;
guint client_cnt = 0;
srv = con->srv;
backends = srv->priv->backends;
cons = srv->priv->cons;
//for test
if (fail_flag == 1000)
{
admin_print_all_backend_cons(con->srv);
return EC_ADMIN_RELOAD_SUCCESS;
}
if (backend_addr_str_array->len != backends->backends->len)
{
g_critical("%s: Number of refresh backends num is not matched, new backends :%d, orignal backends : %d",
G_STRLOC, backend_addr_str_array->len , backends->backends->len);
return EC_ADMIN_RELOAD_FAIL;
}
if (fail_flag != 0 && fail_flag != 1)
{
g_critical("%s: Fail flag of refresh backends must be 0 or 1, but the flag is %d",
G_STRLOC, fail_flag);
return EC_ADMIN_RELOAD_FAIL;
}
addr_array = g_ptr_array_new();
/* 1. 测试DR连通性 */
for (i = 0; i < backend_addr_str_array->len; ++i)
{
new_backend_addr = g_ptr_array_index(backend_addr_str_array, i);
addr = g_new0(admin_network_addr_t, 1);
g_ptr_array_add(addr_array, addr);
s = strchr(new_backend_addr, ':');
if (NULL != s)
{
gint len;
char * port_err = NULL;
network_backend_t* backend;
backend = g_ptr_array_index(backends->backends, i);
//check whether all backends are same
//to do check backend:127.0.0.1:3306, addr:ip:3306?
if (all_same_flag && g_strcasecmp(new_backend_addr, backend->addr->name->str) != 0 ||
backend->state == BACKEND_STATE_DOWN)
{
all_same_flag = 0;
}
len = s - new_backend_addr;
if (len <= MAX_IP_PORT_STRING_LEN)
{
memcpy(addr->ip_address, new_backend_addr, len);
addr->ip_address[len] = '\0';
addr->port = strtoul(s + 1, &port_err, 10);
}
if (len > MAX_IP_PORT_STRING_LEN ||
*(s + 1) == '\0')
{
g_critical("%s: Reload IP-address has to be in the form [<ip>][:<port>], is '%s'. No port number",
G_STRLOC, new_backend_addr);
ret = EC_ADMIN_RELOAD_FAIL;
}
else if (*port_err != '\0')
{
g_critical("%s: Reload IP-address has to be in the form [<ip>][:<port>], is '%s'. Failed to parse the port at '%s'",
G_STRLOC, new_backend_addr, port_err);
ret = EC_ADMIN_RELOAD_FAIL;
}
else
{
addr->addr = network_address_new();
if (network_address_set_address_ip(addr->addr, addr->ip_address, addr->port))
{
g_critical("%s: Reload IP-address %s : %d error",
G_STRLOC, addr->ip_address, addr->port);
ret = EC_ADMIN_RELOAD_FAIL;
}
//ping the ip address and port;
//ret = network_address_set_address_ip(addr, ip_address, port);
//to do
}
}
else
ret = EC_ADMIN_RELOAD_FAIL;
if (EC_ADMIN_RELOAD_FAIL == ret)
{
g_ptr_array_free_all(addr_array, admin_network_addr_free);
return ret;
}
}
//backends are same
if (all_same_flag)
{
g_ptr_array_free_all(addr_array, admin_network_addr_free);
return EC_ADMIN_RELOAD_SUCCESS;
}
/* 2. 置当前所有backends为down */
g_mutex_lock(backends->backends_mutex);
for (i = 0; i < backends->backends->len; ++i)
{
network_backend_t* backend;
backend = g_ptr_array_index(backends->backends, i);
backend->state = BACKEND_STATE_DOWN;
}
g_mutex_unlock(backends->backends_mutex);
/* 3. 当前backend为新地址 */
g_mutex_lock(backends->backends_mutex);
for (i = 0; i < backends->backends->len; ++i)
{
network_backend_t* backend;
backend = g_ptr_array_index(backends->backends, i);
addr = g_ptr_array_index(addr_array, i);
network_address_copy(backend->addr, addr->addr);
// backend->addr->name->len = 0; /* network refresh name */
//
// if (network_address_set_address_ip(backend->addr, addr->ip_address, addr->port))
// {
// g_critical("%s: Reload IP-address %s : %d error"
// G_STRLOC, addr->ip_address, addr->port);
// ret = EC_ADMIN_RELOAD_FAIL;
//
// break;
// }
}
g_mutex_unlock(backends->backends_mutex);
/* 4. 关闭proxy当前所有连接 */
g_mutex_lock(srv->priv->cons_mutex);
for (i = 0; i < cons->len; ++i)
{
con = g_ptr_array_index(cons, i);
//区分了是否为backends的连接
if (con->server && con->server->backend_idx != -1)
{
//g_assert(con->server->fd != -1);
if (con->server->fd != -1)
{
//closesocket(con->server->fd);
con->server->fd_bak = con->server->fd; /* 后端连接暂不关闭，让其正常处理正在进行的事件 */
con->server->fd = -1;
con->server->disconnect_flag = 1;
server_cnt++;
}
//g_assert(con->client && con->client->fd != -1);
if (con->client && con->client->fd != -1)
{
// int c_fd = con->client->fd;
// con->client->fd = -1;
// closesocket(c_fd); /* 需主动关闭前端fd，防止前端一直等待，但会导致con资源没有释放 */
client_cnt++;
}
/* 以上操作可能产生一种情况：客户端请求已在DB执行成功，但前端认为连接已断开 */
switch(con->state)
{
case CON_STATE_CLOSE_CLIENT:
case CON_STATE_CLOSE_SERVER:
case CON_STATE_SEND_ERROR:
case CON_STATE_ERROR:
break;
case CON_STATE_INIT:
case CON_STATE_CONNECT_SERVER:
case CON_STATE_READ_HANDSHAKE:
case CON_STATE_SEND_HANDSHAKE:
case CON_STATE_READ_AUTH:
case CON_STATE_SEND_AUTH:
case CON_STATE_READ_AUTH_RESULT:
case CON_STATE_SEND_AUTH_RESULT:
case CON_STATE_READ_AUTH_OLD_PASSWORD:
case CON_STATE_SEND_AUTH_OLD_PASSWORD:
break;
case CON_STATE_READ_QUERY:
case CON_STATE_SEND_QUERY:
break;
case CON_STATE_READ_QUERY_RESULT:
case CON_STATE_SEND_QUERY_RESULT:
// //需要主动关闭连接
// if (fail_flag == 1)
// {
// if (con->client->fd != -1)
// {
// closesocket(con->client->fd);
// con->client->fd = -1;
// }
// }
break;
case CON_STATE_READ_LOCAL_INFILE_DATA:
case CON_STATE_SEND_LOCAL_INFILE_DATA:
case CON_STATE_READ_LOCAL_INFILE_RESULT:
case CON_STATE_SEND_LOCAL_INFILE_RESULT:
break;
}
}
}
g_message("%s reload backends: connection count %d, close server count %d, close client count %d",
G_STRLOC, srv->priv->cons->len, server_cnt, client_cnt);
g_mutex_unlock(srv->priv->cons_mutex);
if (ret != EC_ADMIN_RELOAD_SUCCESS)
goto destroy_end;
/* 5. 再把后端状态置为unknown，接收新连接 */
g_mutex_lock(backends->backends_mutex);
for (i = 0; i < backends->backends->len; ++i)
{
network_backend_t* backend;
backend = g_ptr_array_index(backends->backends, i);
backend->state = BACKEND_STATE_UNKNOWN;
}
g_mutex_unlock(backends->backends_mutex);
/* 6. 刷新配置 */
ret = admin_configure_flush_to_file(srv);
destroy_end:
g_ptr_array_free_all(addr_array, admin_network_addr_free);
return ret;
}
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;
}
/*
* Initiate the communication with a remote site. When communication is
* established create a minisocket through which the communication can be made
* from now on.
*
* The first argument is the network address of the remote machine.
*
* The argument "port" is the port number on the remote machine to which the
* connection is made. The port number of the local machine is one of the free
* port numbers.
*
* Return value: the minisocket_t created, otherwise NULL with the errorcode
* stored in the "error" variable.
*/
minisocket_t minisocket_client_create(network_address_t addr, int port, minisocket_error *error)
{
minisocket_t newMinisocket;
int totalClientPorts = TCP_MAXIMUM_CLIENT - TCP_MINIMUM_CLIENT + 1;
int convertedPortNumber = (currentClientPort % totalClientPorts) + TCP_MINIMUM_CLIENT;
int i = 1;
int transmitCheck;
if (error == NULL)
return NULL;
semaphore_P(client_mutex);
while (i < totalClientPorts && (minisockets[convertedPortNumber] != NULL))
{
convertedPortNumber = ((currentClientPort + i) % totalClientPorts) + TCP_MINIMUM_CLIENT;
i++;
}
currentClientPort += (i-1);
if (minisockets[convertedPortNumber] != NULL)
{
*error = SOCKET_NOMOREPORTS;
semaphore_V(client_mutex);
return NULL;
}
newMinisocket = minisocket_create_socket(convertedPortNumber);
if (newMinisocket == NULL)
{
*error = SOCKET_OUTOFMEMORY;
semaphore_V(client_mutex);
return NULL;
}
newMinisocket->port_type = TCP_PORT_TYPE_CLIENT;
network_address_copy(addr, newMinisocket->destination_addr);
newMinisocket->destination_port = convertedPortNumber;
minisockets[convertedPortNumber] = newMinisocket;
newMinisocket->status = TCP_PORT_CONNECTING;
semaphore_V(client_mutex);
transmitCheck = transmit_packet(newMinisocket, addr, port, 1, MSG_SYN, 0, NULL, error);
if (transmitCheck == -1)
{
//*error set by transmit_packet()
minisockets[convertedPortNumber] = NULL;
free(newMinisocket);
return NULL;
}
newMinisocket->ack_number++;
//newMinisocket->waiting = TCP_PORT_WAITING_SYNACK;
//semaphore_P(newMinisocket->wait_for_ack_semaphore);
transmitCheck = transmit_packet(newMinisocket, addr, port, 1, MSG_ACK, 0, NULL, error);
if (transmitCheck == -1)
{
minisockets[convertedPortNumber] = NULL;
free(newMinisocket);
return NULL;
}
newMinisocket->status = TCP_PORT_CONNECTED;
*error = SOCKET_NOERROR;
return newMinisocket;
}
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;
}
/* 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;
}