/**
*
*
* @author Francesco Quaglia
*/
int messages_checking(void) {
msg_t msg;
int at_least_one_message = 0;
// Are we in GVT computation phase?
// TODO a cosa serve questa parte qui sotto?!
// if (ComputingGvt() == false)
// send_forced_ack();
// Check whether we have received any ack message
receive_ack();
// If we have pending messages, we process all of them in order to update the queues
while(pending_msg()){
at_least_one_message = 1;
// Receive the message
(void)comm_recv((char*)&msg, sizeof(msg_t), MPI_CHAR, MPI_ANY_SOURCE, MSG_EVENT, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
// For GVT Operations
gvt_messages_rcvd[GidToKernel(msg.sender)] += 1;
// Update the queues
// DataUpdating(&msg);
}
// Did we receive at least one message?
return at_least_one_message;
}
irom static i2c_error_t send_header(int address, i2c_direction_t direction)
{
i2c_error_t error;
bool_t ack;
if(state != i2c_state_header_send)
return(i2c_error_invalid_state_not_send_header);
address <<= 1;
address |= direction == i2c_direction_receive ? 0x01 : 0x00;
state = i2c_state_start_send;
if((error = send_start()) != i2c_error_ok)
return(error);
state = i2c_state_address_send;
if((error = send_byte(address)) != i2c_error_ok)
return(error);
state = i2c_state_address_ack_receive;
if((error = receive_ack(&ack)) != i2c_error_ok)
return(error);
state = i2c_state_address_ack_received;
if(!ack)
return(i2c_error_address_nak);
return(i2c_error_ok);
}
// Receive a handshake record.
static bool receive_handshake(sptps_t *s, const char *data, uint16_t len) {
// Only a few states to deal with handshaking.
switch(s->state) {
case SPTPS_SECONDARY_KEX:
// We receive a secondary KEX request, first respond by sending our own.
if(!send_kex(s))
return false;
case SPTPS_KEX:
// We have sent our KEX request, we expect our peer to sent one as well.
if(!receive_kex(s, data, len))
return false;
s->state = SPTPS_SIG;
return true;
case SPTPS_SIG:
// If we already sent our secondary public ECDH key, we expect the peer to send his.
if(!receive_sig(s, data, len))
return false;
if(s->outstate)
s->state = SPTPS_ACK;
else {
s->outstate = true;
if(!receive_ack(s, NULL, 0))
return false;
s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
s->state = SPTPS_SECONDARY_KEX;
}
return true;
case SPTPS_ACK:
// We expect a handshake message to indicate transition to the new keys.
if(!receive_ack(s, data, len))
return false;
s->receive_record(s->handle, SPTPS_HANDSHAKE, NULL, 0);
s->state = SPTPS_SECONDARY_KEX;
return true;
// TODO: split ACK into a VERify and ACK?
default:
return error(s, EIO, "Invalid session state %d", s->state);
}
}
irom i2c_error_t i2c_send(int address, int length, const uint8_t *bytes)
{
int current;
i2c_error_t error;
bool_t ack;
if(!i2c_flags.init_done)
return(i2c_error_no_init);
if(state != i2c_state_idle)
return(i2c_error_invalid_state_not_idle);
state = i2c_state_header_send;
if((error = send_header(address, i2c_direction_send)) != i2c_error_ok)
return(error);
for(current = 0; current < length; current++)
{
state = i2c_state_data_send_data;
if((error = send_byte(bytes[current])) != i2c_error_ok)
return(error);
state = i2c_state_data_send_ack_receive;
if((error = receive_ack(&ack)) != i2c_error_ok)
return(error);
state = i2c_state_data_send_ack_received;
if(!ack)
return(i2c_error_data_nak);
}
state = i2c_state_stop_send;
if((error = send_stop()) != i2c_error_ok)
return(error);
state = i2c_state_idle;
return(i2c_error_ok);
}
static int do_sending(void)
{
unsigned i;
if (!make_msg())
return stdin_eof ? STATE_EXITING : STATE_CONNECTED;
/* Try to send the message packet multiple times. */
for (i = 1; !exitasap && i <= retransmits; ++i) {
debugf(DEBUG_PACKET, "{Sending seq #}llu{ to #}llu", seq_send, seq_last);
send_packet("MSG1", ack_timeout * i);
while (!exitasap) {
if (poll_both() == 0) {
debug1(DEBUG_STATE, "Timed out waiting for ACK");
break;
}
if (stdin_ready)
read_lines();
if (sock_ready && receive_ack())
return saw_seq_gap ? STATE_DISCONNECTED : STATE_SENDING;
}
}
return STATE_DISCONNECTED;
}
static void handle_rrq(tftp_client_state_t *cli)
{
short pak_type;
short *netbuf_shorts = (short *)cli->block_buffer;
sock_errno_e retcode;
if (cli->state_flags & TFTP_SRV_BLKSIZE) {
handle_oack_transmit(cli);
} else {
handle_data_transmit(cli);
}
while (1) {
retcode = receive_packet(cli->client, cli->block_buffer, &cli->block_buffer_size);
switch (retcode) {
case SOCK_ERR_OK:
break;
case SOCK_ERR_TIMEOUT:
if (handle_timeout(cli)) {
continue;
} else {
return;
}
break;
default:
return;
}
pak_type = ntohs(netbuf_shorts[0]);
switch (pak_type) {
case TFTP_ACK:
if (SOCK_ERR_OK == receive_ack(cli->block_buffer, cli->blockid)) {
if (cli->state_flags & TFTP_SRV_LASTACK) {
return;
} else {
handle_data_transmit(cli);
}
}
break;
case TFTP_ERROR:
receive_error(cli->block_buffer);
return;
case TFTP_RRQ:
/* FALLTHRU */
case TFTP_WRQ:
/* FALLTHRU */
case TFTP_DATA:
/* FALLTHRU */
case TFTP_OACK:
tftp_log_message("Unhandled packet type %d in %s\n", pak_type, __FUNCTION__);
break;
default:
tftp_log_message("Unknown packet type %d in %s\n", pak_type, __FUNCTION__);
break;
}
}
}
int main(int argc, char** argv) {
if(argc != 4){
printf("Usage: %s <server-ip> <port> <directory\n", argv[0]);
return 0;
}
char buffer[(1<<16)+1];
buffer[0] = '\0';
DIR *dir;
struct dirent *ent;
if ((dir = opendir (argv[3])) != NULL) {
//read all files in the directory specified
while ((ent = readdir (dir)) != NULL) {
// send_stuffed_msg(con, ent->d_name);
// if(!receive_ack(con)){
// printf("The server don't seem to support our protocol\n");
// close_connection(con);
// return EXIT_FAILURE;
// }
// bytesTransfered += strlen(ent->d_name)+1;
// bytesTransfered += ACK_LEN;
if(ent->d_name[0] != '.'){
sprintf(buffer, "%s%s\n", buffer, ent->d_name);
}
}
closedir (dir);
} else {
printf("We couldn't open the specified directory\n");
return EXIT_FAILURE;
}
char* address = argv[1];
int port = atoi(argv[2]);
Connection* con = connect_to_server(address, port);
if(con == NULL){
printf("Couldn't connect to the server. Is the address correct? (only ip addesses are supported)\n");
return EXIT_FAILURE;
}
struct timespec beginTime, endTime;
int bytesTransfered = 0;
send_greeting(con);
if(!receive_greet_ack(con)){
printf("The server don't seem to support our protocol\n");
close_connection(con);
return EXIT_FAILURE;
}
send_stuffed_msg(con, argv[3]);
if(!receive_ack(con)){
printf("The server don't seem to support our protocol\n");
close_connection(con);
return EXIT_FAILURE;
}
clock_gettime(CLOCK_REALTIME, &beginTime);
send_stuffed_msg(con, buffer);
if(!receive_ack(con)){
printf("The server don't seem to support our protocol\n");
close_connection(con);
return EXIT_FAILURE;
}
bytesTransfered = strlen(buffer);
clock_gettime(CLOCK_REALTIME, &endTime);
send_farewell(con);
close_connection(con);
double ellapsedTime = (endTime.tv_sec - beginTime.tv_sec) + (endTime.tv_nsec - beginTime.tv_nsec) / 1E9;
printf("The file names were successfully sent %d B to server in %f seconds at %f B/s.\n", bytesTransfered, ellapsedTime, (bytesTransfered/ellapsedTime));
return 0;
}
