void interrupt(int id) {
unsigned long time;
struct timeval tv;
char msg[50];
gettimeofday(&tv, NULL);
time = (unsigned long) (unsigned long long)(tv.tv_sec) * 1000 + (unsigned long long)(tv.tv_usec) / 1000;
if (interrupt_infos[id].occure + interrupt_infos[id].wait <= time) {
interrupt_infos[id].occure = time;
sprintf(msg, "%s", interrupt_infos[id].name);
write_msg_to_client(get_client_socket_fd(), msg);
}
}
void*
receive_thread(void* arg)
{
int socket_fd = get_client_socket_fd();
struct sockaddr_in server_address;
socklen_t server_address_len = sizeof(server_address);
ssize_t msg_len;
char msg[MTN_MSG_LEN + 1];
while((msg_len = recvfrom(socket_fd, msg, MTN_MSG_LEN, 0,
(struct sockaddr*) &server_address, &server_address_len)))
{
msg[msg_len] = '\0';
if(msg_len >= MTN_MSG_TYPE_LEN)
{
mtn_message_type type = get_message_type(msg);
switch(type)
{
case MTN_RESPONSE:
receive_response(msg, &server_address);
break;
case MTN_DM_HEAD:
receive_data_message_head(msg, &server_address);
break;
case MTN_DM_BLOCK:
receive_data_message_block(msg, &server_address);
break;
default:
break;
}
}
}
pthread_exit(NULL);
}
bool
send_request(struct server_data* server, const char* request, int request_length)
{
int socket_fd = get_client_socket_fd();
char ip_address_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &server->address.sin_addr, ip_address_str, INET_ADDRSTRLEN);
int port = ntohs(server->address.sin_port);
char request_type_str[MTN_REQ_TYPE_LEN + 1];
get_request_type_str(request_type_str, get_request_type(request));
if(sendto(socket_fd, request, request_length, 0,
(struct sockaddr *) &(server->address), sizeof(server->address)) == -1)
{
error_errno("cannot send %s request to %s:%d",
request_type_str, ip_address_str, port);
return false;
}
time_t send_time;
if((send_time = time(NULL)) == -1)
{
fatal_error(1, "cannot measure time");
}
info("Sending %s request to %s:%d", request_type_str, ip_address_str, port);
struct timespec timeout;
timeout.tv_sec = send_time + SERVER_RESPONSE_TIMEOUT;
timeout.tv_nsec = 0;
pthread_mutex_lock(&server->mutex);
while(server->state != RESP)
{
if(pthread_cond_timedwait(&response_cond, &server->mutex, &timeout) == ETIMEDOUT)
{
info("Server %s:%d is not responding to %s request",
ip_address_str, port, request_type_str);
server->last_connect_attempt_time = send_time;
server->not_connect_count++;
if(server->not_connect_count % MAX_NOT_CONNECT_COUNT == 0)
{
// client runs out of attempts to connect to the server
// client now waits for next attempt
server->state = WAIT;
}
pthread_mutex_unlock(&server->mutex);
return false;
}
}
char response_type_str[MTN_RES_TYPE_LEN + 1];
get_response_type_str(response_type_str, get_response_type(server->response));
time_t connect_time;
if((connect_time = time(NULL)) == -1)
{
fatal_error(1, "cannot measure time");
}
info("Receiving %s response from %s:%d",
response_type_str, ip_address_str, port);
info("%s", server->response);
server->last_connect_attempt_time = connect_time;
server->not_connect_count = 0;
pthread_mutex_unlock(&server->mutex);
return true;
}
