int main(int argc, char *argv[])
{
msg t;
int i, res;
printf("[SENDER] Starting.\n");
init(HOST, PORT);
printf("[SENDER]: BDP=%d\n", atoi(argv[1]));
float window_size = (float) atoi(argv[1])/(MSGSIZE * 8);
int size = 8;
printf("Window size: %lf = %d\n", window_size, size);
// primim bdp biti, msg_size bytes
//afisati bdp, afisati dim, afisam fiecare send and receiv
// speed mb/s, delay ms
int j;
for (j = 0; j < size; j++) {
printf ("sent %d\n", j);
res = send_message(&t);
if (res < 0) {
perror("[SENDER] Send error. Exiting.\n");
return -1;
}
}
for (i = size; i < COUNT; i++) {
/* cleanup msg */
memset(&t, 0, sizeof(msg));
/* gonna send an empty msg */
t.len = MSGSIZE;
/* wait for ACK */
res = recv_message(&t);
printf ("received %d\n", i);
if (res < 0) {
perror("[SENDER] Receive error. Exiting.\n");
return -1;
}
else {
/* send msg */
if (i < COUNT - size) {
res = send_message(&t);
printf ("sent %d\n", i);
if (res < 0) {
perror("[SENDER] Send error. Exiting.\n");
return -1;
}
}
}
}
printf("[SENDER] Job done, all sent.\n");
return 0;
}
//this is where the server handle requests, you should write your code here
static void handle_request(csiebox_server* server, int conn_fd) {
csiebox_protocol_header header;
memset(&header, 0, sizeof(header));
while (recv_message(conn_fd, &header, sizeof(header))) {
if (header.req.magic != CSIEBOX_PROTOCOL_MAGIC_REQ) {
continue;
}
switch (header.req.op) {
case CSIEBOX_PROTOCOL_OP_LOGIN:
fprintf(stderr, ">>>>>>>>>> login\n");
csiebox_protocol_login req;
if (complete_message_with_header(conn_fd, &header, &req)) {
login(server, conn_fd, &req);
}
break;
case CSIEBOX_PROTOCOL_OP_SYNC_META:
fprintf(stderr, ">>>>>>>>>> sync meta\n");
csiebox_protocol_meta meta;
if (complete_message_with_header(conn_fd, &header, &meta)) {
sync_meta(server, conn_fd, &meta);
}
break;
case CSIEBOX_PROTOCOL_OP_SYNC_FILE:
fprintf(stderr, ">>>>>>>>>> sync file\n");
csiebox_protocol_file file;
if (complete_message_with_header(conn_fd, &header, &file)) {
sync_file(server, conn_fd, &file);
}
break;
case CSIEBOX_PROTOCOL_OP_SYNC_HARDLINK:
fprintf(stderr, ">>>>>>>>>> sync hardlink\n");
csiebox_protocol_hardlink hardlink;
if (complete_message_with_header(conn_fd, &header, &hardlink)) {
sync_hardlink(server, conn_fd, &hardlink);
}
break;
case CSIEBOX_PROTOCOL_OP_SYNC_END:
fprintf(stderr, "========== sync end\n");
break;
case CSIEBOX_PROTOCOL_OP_RM:
fprintf(stderr, ">>>>>>>>>> sync rm\n");
csiebox_protocol_rm rm;
if (complete_message_with_header(conn_fd, &header, &rm)) {
sync_rm(server, conn_fd, &rm);
}
break;
default:
fprintf(stderr, ">>>>>>>>>> unknown op %x\n", header.req.op);
break;
}
}
fprintf(stderr, "========== end of connection\n");
logout(server, conn_fd);
}
struct message_and_fd multiplexed_recv_message(int * max_fd, fd_set * client_fds, fd_set * listener_fds){
/* max_fd is a pointer to an int that describes the max value of an fd in client_fds */
/* client_fds is the set of all fds that we want to monitor. This includes listeners and clients */
/* listener_fds is the set of all fds that are waiting for new incomming connections */
/* This method will return the first message it gets from any client */
struct sockaddr_storage remoteaddr;
fd_set updated_fds;
FD_ZERO(&updated_fds);
while(1){
updated_fds = *client_fds;
if (select((*max_fd)+1, &updated_fds, NULL, NULL, NULL) == -1) {
perror("select");
exit(4);
}
int i;
for(i = 0; i <= *max_fd; i++) {
/* If we can read from it and it is a listener that accepts new connections */
if (FD_ISSET(i, &updated_fds) && FD_ISSET(i, listener_fds) ) {
//printf("Accepting incomming connection.\n");
socklen_t addrlen = sizeof remoteaddr;
int newfd = accept(i, (struct sockaddr *)&remoteaddr, &addrlen);
if (newfd == -1) {
perror("accept");
} else {
FD_SET(newfd, client_fds);
if (newfd > *max_fd) {
*max_fd = newfd;
}
}
/* Data from an already open connection */
}else if (FD_ISSET(i, &updated_fds)){
//printf("Accepting incomming data.\n");
struct message_and_fd rtn;
rtn.fd = i;
rtn.message = recv_message(i);
if (rtn.message){
return rtn;
} else {
// the node on the other end of this socket terminated or went down
close(i);
FD_CLR(i, client_fds);
// inform caller of the termination in case clean up is necessary
return rtn;
}
}
}
}
}
int execute_test ( const char * test_name, void(*test_func)(void) )
{
if ( 0 != pipe(pipefd) )
{
fprintf(stderr, "Failed to open pipe for %s\n", test_name);
exit(1);
}
kidpid = fork();
if ( 0 == kidpid )
{
(*test_func)();
return 0;
}
else
{
int kid_status;
tested ++;
waitpid(kidpid, &kid_status, 0);
if ( WIFEXITED ( kid_status ) && WEXITSTATUS ( kid_status ) != 0 )
{
if ( WIFEXITED ( kid_status ) )
{
char * message = recv_message ( );
printf("%s\n", message);
free ( message );
printf(" PID %d exited with status %d\n", kidpid, WEXITSTATUS ( kid_status ) );
}
}
else if ( WIFSIGNALED ( kid_status ) )
{
printf("Test %s (%d): ", test_name, kidpid);
printf("terminated by signal %d"
#ifdef WCOREDUMP
WCOREDUMP ( kid_status ) ? "; core dumped" : "; no core"
#endif // WCOREDUMP
"\n", WTERMSIG ( kid_status ) );
}
else
{
passed ++;
}
return 1;
}
}
/*
* Class: com_netifera_platform_internal_system_privd_PrivilegeDaemonNative
* Method: receiveMessage
* Signature: ([B)I
*/
JNIEXPORT jint JNICALL Java_com_netifera_platform_internal_system_privd_PrivilegeDaemonNative_receiveMessage
(JNIEnv *env, jobject obj, jbyteArray recvBuffer)
{
jbyte *recv_buffer = (*env)->GetByteArrayElements(env, recvBuffer, NULL);
if(recv_buffer == NULL) {
error_message = "Failed to extract recvBuffer";
return -1;
}
int recv_size = (*env)->GetArrayLength(env, recvBuffer);
int ret = recv_message(recv_buffer, recv_size);
(*env)->ReleaseByteArrayElements(env, recvBuffer, recv_buffer, 0);
return ret;
}
//send message
bool activemq_sync_producer::send_message(const std::string& request, std::string& response, int time)
{
try
{
char uuid_str[37];
uuid_str[36] = 0;
uuid_clear(_uuid);
uuid_generate_time_safe(_uuid);
uuid_unparse(_uuid, uuid_str);
//发送消息
std::auto_ptr<cms::TextMessage> ptr_message(_ptr_session->createTextMessage(request));
ptr_message->setCMSReplyTo(_ptr_recv_queue.get());
ptr_message->setCMSCorrelationID(uuid_str);
_ptr_send_message->send(ptr_message.get());
bool recv_data = false;
while (1)
{
std::auto_ptr<cms::TextMessage> recv_message(dynamic_cast<cms::TextMessage*>(_ptr_recv_message->receive(time)));
if (NULL != recv_message.get())
{
if (recv_message->getCMSCorrelationID().compare(uuid_str) == 0)
{
response = recv_message->getText();
recv_data = true;
break;
}
else
{
}
}
else
{
break;
}
}
return recv_data;
}
catch (cms::CMSException& e)
{
printf("Producer run() CMSException \n");
e.printStackTrace();
return false;
}
}
int
handle_logout_command(struct thread_data_t * datum, char * args)
{
int i, len;
char buffer[MAX_COMMAND_LENGTH];
/* Logout command takes no arguments */
#ifndef NDEBUG
if (*args != '\0') {
fprintf(stderr,
"[thread %lu] WARNING: ignoring '%s' (argument residue)\n",
datum->id, args);
}
#endif
/* Prepare a reply dependent on our state */
memset(buffer, '\0', MAX_COMMAND_LENGTH);
if (datum->credentials.userlength) {
snprintf(buffer, MAX_COMMAND_LENGTH, "Goodbye, %s!",
datum->credentials.username);
} else {
snprintf(buffer, MAX_COMMAND_LENGTH, "LOGOUT ERROR");
}
salt_and_pepper(buffer, NULL, &datum->buffet);
encrypt_message(&datum->buffet, datum->credentials.key);
/* Clear the credential bits from the key */
if (datum->credentials.userlength) {
len = datum->credentials.userlength;
for (i = 0; i < AUTH_KEY_LENGTH; ++i) {
datum->credentials.key[i] ^=
datum->credentials.username[i % len];
}
memset(&datum->credentials.username, '\0', MAX_COMMAND_LENGTH);
datum->credentials.userlength = 0;
}
send_message(&datum->buffet, datum->sock);
/* Handle verification (should fail) */
recv_message(&datum->buffet, datum->sock);
decrypt_message(&datum->buffet, datum->credentials.key);
for (i = 0; i < MAX_COMMAND_LENGTH; ++i) {
datum->buffet.pbuffer[i] =
datum->buffet.tbuffer[MAX_COMMAND_LENGTH - 1 - i];
}
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
return BANKING_SUCCESS;
}
static int sync_hardlink(csiebox_server *server, int conn_fd, csiebox_protocol_hardlink *hardlink)/*{{{*/
{
char client_src_path[PATH_MAX];
char client_target_path[PATH_MAX];
if (!recv_message(conn_fd, client_src_path, PATH_MAX) ||
!recv_message(conn_fd, client_target_path, PATH_MAX)) {
fprintf(stderr, "receive path error\n");
return 0;
}
// sync hardlink
fprintf(stderr, "sync hardlink : receive path :\n\t%s\n\t%s\n", client_src_path, client_target_path);
char src_path[PATH_MAX], target_path[PATH_MAX];
sprintf(src_path, "%s%s", get_user_homedir(server, server->client[conn_fd]), make_path(client_src_path));
sprintf(target_path, "%s%s", get_user_homedir(server, server->client[conn_fd]), make_path(client_target_path));
remove(target_path);
fprintf(stderr, "sync hardlink : remove : %s\n", target_path);
link(src_path, target_path);
// send back message for time
csiebox_protocol_header header;
memset(&header, 0, sizeof(header));
header.res.magic = CSIEBOX_PROTOCOL_MAGIC_RES;
header.res.op = CSIEBOX_PROTOCOL_OP_SYNC_HARDLINK;
header.res.status = CSIEBOX_PROTOCOL_STATUS_OK;
send_message(conn_fd, &header, sizeof(header));
fprintf(stderr, "sync hardlink : success\n");
// utime
struct utimbuf meta_time;
memset(&meta_time, 0, sizeof(meta_time));
recv_message(conn_fd, &meta_time, sizeof(meta_time));
utime(src_path, &meta_time);
fprintf(stderr, "sync hardlink : utime\n");
return 1;
}/*}}}*/
//Basic test for create/attach and exit.
int pc_library_mutatee()
{
int result;
void *handlea, *handleb;
syncloc msg;
//fprintf(stderr, "Entering pc_library_mutatee\n");
result = initProcControlTest(threadFunc, NULL);
//fprintf(stderr, "Done with init, pc_library_mutatee\n");
if (result != 0) {
output->log(STDERR, "Initialization failed\n");
return -1;
}
//fprintf(stderr, "Opening libtestA pc_library_mutatee\n");
handlea = openLib(LIBTESTA);
//fprintf(stderr, "Opening libtestB pc_library_mutatee\n");
handleb = openLib(LIBTESTB);
//fprintf(stderr, "Closing libtestB\n");
closeLib(LIBTESTB, handleb);
//fprintf(stderr, "Closing libtestB\n");
closeLib(LIBTESTA, handlea);
msg.code = SYNCLOC_CODE;
result = send_message((unsigned char *) &msg, sizeof(syncloc));
if (result == -1) {
output->log(STDERR, "Failed to send sync message\n");
return -1;
}
result = recv_message((unsigned char *) &msg, sizeof(syncloc));
if (result == -1) {
output->log(STDERR, "Failed to recv sync message\n");
return -1;
}
if (msg.code != SYNCLOC_CODE) {
output->log(STDERR, "Recieved unexpected sync message\n");
return -1;
}
result = finiProcControlTest(0);
if (result != 0) {
output->log(STDERR, "Finalization failed\n");
return -1;
}
test_passes(testname);
return 0;
}
// done
static int handle_request(csiebox_server* server, int conn_fd) {
csiebox_protocol_header header;
memset(&header, 0, sizeof(header));
int connection = recv_message(conn_fd, &header, sizeof(header));
if (connection > 0 && header.req.magic == CSIEBOX_PROTOCOL_MAGIC_REQ) {
switch (header.req.op) {
case CSIEBOX_PROTOCOL_OP_LOGIN:
fprintf(stderr, "========== ");
csiebox_protocol_login req;
if (complete_message_with_header(conn_fd, &header, &req)) {
login(server, conn_fd, &req);
fprintf(stderr, "[%s] [fd = %d] login\n",
server->client[conn_fd]->account.user, conn_fd);
}
return 0;
case CSIEBOX_PROTOCOL_OP_SYNC_META:
fprintf(stderr, "sync meta\n");
csiebox_protocol_meta meta;
if (complete_message_with_header(conn_fd, &header, &meta)) {
sync_file(server, conn_fd, &meta);
}
return 0;
case CSIEBOX_PROTOCOL_OP_SYNC_END:
fprintf(stderr, "========== [%s] [fd = %d] sync end\n",
server->client[conn_fd]->account.user, conn_fd);
sync_end(server, conn_fd);
return 0;
case CSIEBOX_PROTOCOL_OP_RM:
fprintf(stderr, "sync rm\n");
csiebox_protocol_rm rm;
if (complete_message_with_header(conn_fd, &header, &rm)) {
rm_file(server, conn_fd, &rm);
}
return 0;
default:
fprintf(stderr, "unknow op %x\n", header.req.op);
return 0;
}
} else if (connection <= 0) {
fprintf(stderr, "========== [%s] [fd = %d] logout\n",
server->client[conn_fd]->account.user, conn_fd);
logout(server, conn_fd);
return 1;
}
return 0;
}
void chat_recv(void *tbp)
{
int len;
char recv_msg[2500];
textbox t = tbp;
(void)t;
if (main_console->tabs->active == 2)
{
memset(&recv_msg[0], 0, 2500);
if ((len = recv_message(&recv_msg[0])) > 0)
{
textbox_add_text(main_console->tb_out, &recv_msg[0]);
}
}
set_input(main_console->tb_in->data, 1000);
}
Bitmap get_framebuffer(size_t width, size_t height) {
FramebufferInfo fb = {
width - 2 * V_OFFSET, height - 2 * V_OFFSET,
width, height,
0, 24,
0, 0,
NULL, 0};
send_message(1, (uint)(&fb) + 0x40000000);
uint status = recv_message(1);
Bitmap bmp = {
width,
height,
NULL};
if(status == 0) {
//while(!fb.buffer) {}
bmp.data = phys_to_virt(fb.buffer);
}
return bmp;
}
static void sync_file_data(
csiebox_client* client, char* path) {
fprintf(stderr, "file_data: %s\t", path);
struct stat stat;
memset(&stat, 0, sizeof(stat));
lstat(path, &stat);
csiebox_protocol_file file;
memset(&file, 0, sizeof(file));
file.message.header.req.magic = CSIEBOX_PROTOCOL_MAGIC_REQ;
file.message.header.req.op = CSIEBOX_PROTOCOL_OP_SYNC_FILE;
file.message.header.req.client_id = client->client_id;
file.message.header.req.datalen = sizeof(file) - sizeof(csiebox_protocol_header);
if ((stat.st_mode & S_IFMT) == S_IFDIR) {
file.message.body.datalen = 0;
fprintf(stderr, "dir, datalen: %zu\n", file.message.body.datalen);
send_message(client->conn_fd, &file, sizeof(file));
} else {
int fd = open(path, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "open fail\n");
file.message.body.datalen = 0;
send_message(client->conn_fd, &file, sizeof(file));
} else {
file.message.body.datalen = lseek(fd, 0, SEEK_END);
fprintf(stderr, "reg, datalen: %zd\n", file.message.body.datalen);
send_message(client->conn_fd, &file, sizeof(file));
lseek(fd, 0, SEEK_SET);
char buf[4096];
memset(buf, 0, 4096);
size_t readlen;
while ((readlen = read(fd, buf, 4096)) > 0) {
send_message(client->conn_fd, buf, readlen);
}
close(fd);
}
}
csiebox_protocol_header header;
recv_message(client->conn_fd, &header, sizeof(header));
if (header.res.status != CSIEBOX_PROTOCOL_STATUS_OK) {
fprintf(stderr, "sync data fail: %s\n", path);
}
}
int expect_message(SrsMessage** pmsg, T** ppacket)
{
*pmsg = NULL;
*ppacket = NULL;
int ret = ERROR_SUCCESS;
while (true) {
SrsMessage* msg = NULL;
if ((ret = recv_message(&msg)) != ERROR_SUCCESS) {
if (ret != ERROR_SOCKET_TIMEOUT && !srs_is_client_gracefully_close(ret)) {
srs_error("recv message failed. ret=%d", ret);
}
return ret;
}
srs_verbose("recv message success.");
SrsPacket* packet = NULL;
if ((ret = decode_message(msg, &packet)) != ERROR_SUCCESS) {
srs_error("decode message failed. ret=%d", ret);
srs_freep(msg);
srs_freep(packet);
return ret;
}
T* pkt = dynamic_cast<T*>(packet);
if (!pkt) {
srs_info("drop message(type=%d, size=%d, time=%"PRId64", sid=%d).",
msg->header.message_type, msg->header.payload_length,
msg->header.timestamp, msg->header.stream_id);
srs_freep(msg);
srs_freep(packet);
continue;
}
*pmsg = msg;
*ppacket = pkt;
break;
}
return ret;
}
int main(int argc, char *argv[])
{
int sockfd;
if (argc < 3) {
usage();
exit(0);
}
if( (sockfd = open_connection_to( argv[1], atoi(argv[2]))) == 0) {
report_error( "couldn't open connection to destination" );
return -1;
}
recv_message( sockfd );
read_one_line( sockfd );
disconnect_server( sockfd );
return 0;
}
void conn_listen(int *socket) {
char *buffer, *resp;
int res;
// repeatedly respond to lines sent by the client
do {
// receive a string from this client's connection socket
res = recv_message(*socket, &buffer);
if (res < 0) {
send_string(*socket, "NACK");
continue;
}
resp = process_msg(buffer);
// printf("Client says \"%s\".\nResponding \"%s\"\n", buffer, resp);
printf("Responding \"%s\"\n", resp);
send_message(*socket, resp); // Note that process_msg() may have side effects.
} while (res > 0 && strcmp(buffer,"STOP"));
close(*socket);
}
static gboolean simd_data_cb(GIOChannel *io, GIOCondition cond, gpointer data)
{
char buf[SAP_BUF_SIZE];
gsize bytes_read;
GIOStatus gstatus;
if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
DBG("Error condition on sim socket (0x%x)", cond);
return FALSE;
}
gstatus = g_io_channel_read_chars(io, buf, sizeof(buf), &bytes_read,
NULL);
if (gstatus != G_IO_STATUS_NORMAL) {
sap_error("error while reading from channel (%d)", gstatus);
return TRUE;
}
if (recv_message(buf, bytes_read) < 0)
sap_error("error while parsing STE Sim message");
return TRUE;
}
static int handle_download(csiebox_client *client)
{
csiebox_protocol_header header;
memset(&header, 0, sizeof(header));
recv_message(client->conn_fd, &header, sizeof(header));
if (header.res.magic == CSIEBOX_PROTOCOL_MAGIC_RES) {
switch (header.res.op) {
case CSIEBOX_PROTOCOL_OP_SYNC_META:
fprintf(stderr, ">>> download meta: ");
csiebox_protocol_meta meta;
complete_message_with_header(client->conn_fd, &header, &meta);
download_meta(client, &meta);
return 0;
case CSIEBOX_PROTOCOL_OP_SYNC_FILE:
fprintf(stderr, ">>> download file\n");
csiebox_protocol_file file;
complete_message_with_header(client->conn_fd, &header, &file);
download_file(client, &file);
return 0;
case CSIEBOX_PROTOCOL_OP_RM:
fprintf(stderr, ">>> download rm: ");
csiebox_protocol_rm rm;
complete_message_with_header(client->conn_fd, &header, &rm);
download_rm(client, &rm);
return 0;
case CSIEBOX_PROTOCOL_OP_SYNC_END:
fprintf(stderr, ">>> download end\n");
char buffer[EVENT_BUF_LEN];
while(read(client->inotify_fd, buffer, EVENT_BUF_LEN) == EVENT_BUF_LEN);
return 1;
default :
fprintf(stderr, "========== unknown op: %x\n", header.res.op);
return 1;
}
}
return 1;
}
status_t handle_client_message(SSL *ssl, msg_t *req, msg_t *resp) {
status_t rt;
if(STATUS_FAILURE == recv_message(ssl, resp)) {
return STATUS_FAILURE;
}
switch(resp->hdr.type) {
case RSP_AUTH:
//resp->hdr.type = RSP_AUTH;
//handle_auth_res(resp);
break;
case RSP_GET:
rt = handle_get_resp(req, resp);
break;
case RSP_PUT:
rt = handle_put_resp(req, resp);
break;
case RSP_DELG:
rt = handle_delg_resp(req, resp);
break;
}
return rt;
}
int
handle_login_command(struct thread_data_t * datum, char * args)
{
size_t i, len;
char buffer[MAX_COMMAND_LENGTH];
/* The login argument takes one argument */
#ifndef NDEBUG
if (*args == '\0') {
fprintf(stderr,
"[thread %lu] WARNING: [%s] arguments empty\n",
datum->id, "login");
} else {
fprintf(stderr,
"[thread %lu] INFO: [%s] '%s' (arguments)\n",
datum->id, "login", args);
}
#endif
/* TODO verify they're an actual user of the system */
/* Modify the key using bits from the username */
len = strnlen(args, MAX_COMMAND_LENGTH);
for (i = 0; i < AUTH_KEY_LENGTH; ++i) {
datum->credentials.key[i] ^= args[i % len];
}
/* Turn around the message */
for (i = 0; i < MAX_COMMAND_LENGTH; ++i) {
datum->buffet.pbuffer[i] =
datum->buffet.tbuffer[MAX_COMMAND_LENGTH - 1 - i];
}
/* Echo this message with the modified key */
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
/* Receive the PIN */
recv_message(&datum->buffet, datum->sock);
decrypt_message(&datum->buffet, datum->credentials.key);
/* Copy the args backward TODO better auth, use pin as salt */
memset(buffer, '\0', MAX_COMMAND_LENGTH);
for (i = 0; i < len; ++i) {
buffer[i] = args[len - i - 1];
}
/* Check the buffer matches the args */
if (strncmp(buffer, datum->buffet.tbuffer, len)
|| do_lookup(session_data.db_conn, NULL, args, len, NULL)) {
snprintf(buffer, MAX_COMMAND_LENGTH, "LOGIN ERROR");
/* Remove the previously added bits */
for (i = 0; i < AUTH_KEY_LENGTH; ++i) {
datum->credentials.key[i] ^= args[i % len];
}
} else {
snprintf(buffer, MAX_COMMAND_LENGTH, "%s, %s!", AUTH_LOGIN_MSG, args);
/* We have now authenticated the user */
memset(datum->credentials.username, '\0', MAX_COMMAND_LENGTH);
strncpy(datum->credentials.username, args, len);
datum->credentials.userlength = len;
}
salt_and_pepper(buffer, NULL, &datum->buffet);
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
/* Catch authentication check */
recv_message(&datum->buffet, datum->sock);
decrypt_message(&datum->buffet, datum->credentials.key);
/* Turn around the message */
for (i = 0; i < MAX_COMMAND_LENGTH; ++i) {
datum->buffet.pbuffer[i] =
datum->buffet.tbuffer[MAX_COMMAND_LENGTH - 1 - i];
}
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
return BANKING_SUCCESS;
}
void reliablyReceive(unsigned short int myUDPport, char* destinationFile){
/*FILE * pFile;
pFile = fopen (destinationFile, "wb");*/
std::ofstream outfile(destinationFile, std::ofstream::binary);
int i;
bool sentinal = true;
while(sentinal){
message msg;
recv_message(&msg);
//received the in order packet and the packet haven't been received before
if((msg.Sequence_number == Sequence_number) && (!received_packet[msg.Sequence_number]))
{
received_packet[Sequence_number/BUFFER_SIZE] = true;
//write the message to memory
for(i = 0; i < BUFFER_SIZE; i ++)
{
file_to_write[Sequence_number/BUFFER_SIZE][i] = msg.messages[i];
}
//not reaching end of file
if(msg.messages[BUFFER_SIZE-1] != '\0')
{
Sequence_number += BUFFER_SIZE;
//send ack for next packet
ack back_ack;
back_ack.request_sequence_number = Sequence_number;
send_ack(sender_ip, myUDPport-1, back_ack);
} else
//reaching end of file
{
sentinal = false;
}
// fwrite (msg.messages , sizeof(char), sizeof(msg.messages), pFile);
} else if(msg.Sequence_number > Sequence_number)
//packet is later packet, buffer those first
{
//buffer the message
for(i = 0; i < BUFFER_SIZE; i ++)
{
receive_buffer[msg.Sequence_number/BUFFER_SIZE][i] = msg.messages[i];
}
//send duplicate ack
ack back_ack;
back_ack.request_sequence_number = Sequence_number;
send_ack(sender_ip, myUDPport-1, back_ack);
}
//check the buffer if there is any packet buffered that can be delivered
while(receive_buffer[Sequence_number/BUFFER_SIZE][0]!= '\0')
{
received_packet[Sequence_number/BUFFER_SIZE] = true;
for(i = 0; i < BUFFER_SIZE; i++)
{
file_to_write[Sequence_number/BUFFER_SIZE][i] = receive_buffer[Sequence_number/BUFFER_SIZE][i];
}
//not reaching end of file
if(receive_buffer[Sequence_number/BUFFER_SIZE][BUFFER_SIZE-1] != '\0')
{
Sequence_number += BUFFER_SIZE;
} else
//reaching end of file
{
sentinal = false;
break;
}
// fwrite (receive_buffer[Sequence_number/BUFFER_SIZE] , sizeof(char), sizeof(receive_buffer[Sequence_number/BUFFER_SIZE]), pFile);
}
}
i = 0;
for(i = 0; i < Sequence_number/BUFFER_SIZE; i++){
//fwrite (file_to_write[i] , sizeof(char), sizeof(file_to_write[i]), pFile);
outfile.write(file_to_write[i], sizeof(file_to_write[i]));
}
int j = 0;
while(file_to_write[i][j] != '\0'){
j++;
}
outfile.write(file_to_write[i], j-1);
//printf("writing to file: %d\n", i);
//fclose (pFile);
}
/* this is the main function with the loops and modes */
void shoot(char *buf, int buff_size)
{
struct timespec sleep_ms_s, sleep_rem;
int ret, cseqtmp, rand_tmp;
char buf2[BUFSIZE], buf3[BUFSIZE], lport_str[LPORT_STR_LEN];
/* delays.retryAfter = DEFAULT_TIMEOUT; */
if (transport == SIP_UDP_TRANSPORT) {
delays.retryAfter = timer_t1;
}
else {
delays.retryAfter = timer_final;
}
inv_trans = 0;
cseq_counter = 1;
usrlocstep = REG_REP;
/* initalize local vars */
cdata.dontsend=cdata.dontrecv=counters.retrans_r_c=counters.retrans_s_c= 0;
delays.big_delay=counters.send_counter=counters.run= 0;
timers.delaytime.tv_sec = 0;
timers.delaytime.tv_usec = 0;
usern = NULL;
/* initialize local arrays */
memset(buf2, 0, BUFSIZE);
memset(buf3, 0, BUFSIZE);
memset(lport_str, 0, LPORT_STR_LEN);
cdata.csock = cdata.usock = -1;
cdata.connected = 0;
cdata.buf_tmp = NULL;
cdata.buf_tmp_size = 0;
memset(&(timers.sendtime), 0, sizeof(timers.sendtime));
memset(&(timers.recvtime), 0, sizeof(timers.recvtime));
memset(&(timers.firstsendt), 0, sizeof(timers.firstsendt));
memset(&(timers.starttime), 0, sizeof(timers.starttime));
memset(&(timers.delaytime), 0, sizeof(timers.delaytime));
req = buf;
rep = buf2;
rec = buf3;
create_sockets(&cdata);
if (sleep_ms != 0) {
if (sleep_ms == -2) {
rand_tmp = rand();
sleep_ms_s.tv_sec = rand_tmp / 1000;
sleep_ms_s.tv_nsec = (rand_tmp % 1000) * 1000000;
}
else {
sleep_ms_s.tv_sec = sleep_ms / 1000;
sleep_ms_s.tv_nsec = (sleep_ms % 1000) * 1000000;
}
}
if (replace_b == 1){
replace_string(req, "$dsthost$", domainname);
replace_string(req, "$srchost$", fqdn);
sprintf(lport_str, "%i", lport);
replace_string(req, "$port$", lport_str);
if (username)
replace_string(req, "$user$", username);
}
if (replace_str)
replace_strings(req, replace_str);
/* set all regular expression to simplfy the result code indetification */
regcomp(&(regexps.replyexp), "^SIP/[0-9]\\.[0-9] [1-6][0-9][0-9]",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.proexp), "^SIP/[0-9]\\.[0-9] 1[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.okexp), "^SIP/[0-9]\\.[0-9] 2[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.redexp), "^SIP/[0-9]\\.[0-9] 3[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.authexp), "^SIP/[0-9]\\.[0-9] 40[17] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.errexp), "^SIP/[0-9]\\.[0-9] 4[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.tmhexp), "^SIP/[0-9]\\.[0-9] 483 ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
if (username) {
if (nameend > 0) {
usern = str_alloc(strlen(username) + 12);
create_usern(usern, username, namebeg);
}
else {
if (*(username + strlen(username) - 1) != '@') {
usern = str_alloc(strlen(username) + 2);
create_usern(usern, username, -1);
}
else {
usern = username;
}
}
}
if (usrloc == 1||invite == 1||message == 1){
/* calculate the number of required steps and create initial mes */
if (usrloc == 1) {
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
usrlocstep=REG_REP;
}
else if (invite == 1) {
create_msg(REQ_INV, req, rep, usern, cseq_counter);
inv_trans = 1;
usrlocstep=INV_RECV;
}
else {
create_msg(REQ_MES, req, rep, usern, cseq_counter);
if (mes_body)
usrlocstep=MES_OK_RECV;
else
usrlocstep=MES_RECV;
}
}
else if (trace == 1){
/* for trace we need some spezial initis */
namebeg=0;
create_msg(REQ_OPT, req, NULL, usern, cseq_counter);
set_maxforw(req, namebeg);
}
else if (flood == 1){
if (nameend<=0) nameend=INT_MAX;
namebeg=1;
create_msg(REQ_FLOOD, req, NULL, usern, cseq_counter);
}
else if (randtrash == 1){
counters.randretrys=0;
namebeg=1;
create_msg(REQ_RAND, req, NULL, usern, cseq_counter);
nameend=(int)strlen(req);
if (trashchar == 1){
if (trashchar < nameend)
nameend=trashchar;
else
fprintf(stderr, "warning: number of trashed chars to big. setting to "
"request length\n");
}
trash_random(req);
}
else {
/* for none of the modes we also need some inits */
if (file_b == 0) {
namebeg=1;
create_msg(REQ_OPT, req, NULL, usern, cseq_counter);
}
else {
if (STRNCASECMP(req, INV_STR, INV_STR_LEN) == 0) {
inv_trans = 1;
}
if(via_ins == 1)
add_via(req);
}
/* delays.retryAfter = delays.retryAfter / 10; */
if(maxforw!=-1)
set_maxforw(req, maxforw);
}
cdata.connected = set_target(&(cdata.adr), address, rport, cdata.csock, cdata.connected);
/* here we go until someone decides to exit */
while(1) {
before_sending();
if (sleep_ms == -2) {
rand_tmp = rand();
sleep_ms_s.tv_sec = rand_tmp / 1000;
sleep_ms_s.tv_nsec = (rand_tmp % 1000) * 1000;
}
if (sleep_ms != 0) {
dbg("sleeping for %li s + %li ns\n", sleep_ms_s.tv_sec, sleep_ms_s.tv_nsec);
nanosleep(&sleep_ms_s, &sleep_rem);
}
send_message(req, &cdata, &counters, &timers);
/* in flood we are only interested in sending so skip the rest */
if (flood == 0) {
ret = recv_message(rec, BUFSIZE, inv_trans, &delays, &timers,
&counters, &cdata, ®exps);
if(ret > 0)
{
if (usrlocstep == INV_OK_RECV) {
swap_ptr(&rep, &req);
}
/* send ACK for non-provisional reply on INVITE */
if ((STRNCASECMP(req, "INVITE", 6)==0) &&
(regexec(&(regexps.replyexp), rec, 0, 0, 0) == REG_NOERROR) &&
(regexec(&(regexps.proexp), rec, 0, 0, 0) == REG_NOMATCH)) {
build_ack(req, rec, rep, ®exps);
cdata.dontsend = 0;
inv_trans = 0;
/* lets fire the ACK to the server */
send_message(rep, &cdata, &counters, &timers);
inv_trans = 1;
}
/* check for old CSeq => ignore retransmission */
cseqtmp = cseq(rec);
if ((0 < cseqtmp) && (cseqtmp < cseq_counter)) {
if (verbose>0) {
printf("ignoring retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend = 1;
continue;
}
else if (regexec(&(regexps.authexp), rec, 0, 0, 0) == REG_NOERROR) {
if (!username && !auth_username) {
if (timing > 0) {
timing--;
if (timing == 0) {
if (counters.run == 0) {
counters.run++;
}
printf("%.3f/%.3f/%.3f ms\n", delays.small_delay, delays.all_delay / counters.run, delays.big_delay);
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
counters.run++;
new_transaction(req, rep);
delays.retryAfter = timer_t1;
continue;
}
fprintf(stderr, "%s\nerror: received 40[17] but cannot "
"authentication without a username or auth username\n", rec);
log_message(req);
exit_code(2, __PRETTY_FUNCTION__, "missing username for authentication");
}
/* prevents a strange error */
regcomp(&(regexps.authexp), "^SIP/[0-9]\\.[0-9] 40[17] ", REG_EXTENDED|REG_NOSUB|REG_ICASE);
insert_auth(req, rec);
if (verbose > 2)
printf("\nreceived:\n%s\n", rec);
new_transaction(req, rep);
continue;
} /* if auth...*/
/* lets see if received a redirect */
if (redirects == 1 && regexec(&(regexps.redexp), rec, 0, 0, 0) == REG_NOERROR) {
handle_3xx(&(cdata.adr));
} /* if redircts... */
else if (trace == 1) {
trace_reply();
} /* if trace ... */
else if (usrloc == 1||invite == 1||message == 1) {
handle_usrloc();
}
else if (randtrash == 1) {
handle_randtrash();
}
else {
handle_default();
} /* redirect, auth, and modes */
} /* ret > 0 */
else if (ret == -1) { // we did not got anything back, send again
/* no re-transmission on reliable transports */
if (transport != SIP_UDP_TRANSPORT) {
cdata.dontsend = 1;
}
continue;
}
else if (ret == -2) { // we received non-matching ICMP
cdata.dontsend = 1;
continue;
}
else {
if (usrloc == 1) {
printf("failed\n");
}
perror("socket error");
exit_code(3, __PRETTY_FUNCTION__, "internal socket error");
}
} /* !flood */
else {
if (counters.send_counter == 1) {
memcpy(&(timers.firstsendt), &(timers.sendtime), sizeof(struct timeval));
}
if (namebeg==nameend) {
printf("flood end reached\n");
printf("it took %.3f ms seconds to send %i request.\n",
deltaT(&(timers.firstsendt), &(timers.sendtime)), namebeg);
printf("we sent %f requests per second.\n",
(namebeg/(deltaT(&(timers.firstsendt), &(timers.sendtime)))*1000));
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
namebeg++;
cseq_counter++;
create_msg(REQ_FLOOD, req, NULL, usern, cseq_counter);
}
} /* while 1 */
/* this should never happen any more... */
if (randtrash == 1) {
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
printf("** give up retransmissioning....\n");
if (counters.retrans_r_c>0 && (verbose > 1)) {
printf("%i retransmissions received during test\n", counters.retrans_r_c);
}
if (counters.retrans_s_c>0 && (verbose > 1)) {
printf("sent %i retransmissions during test\n", counters.retrans_s_c);
}
exit_code(3, __PRETTY_FUNCTION__, "got outside of endless messaging loop");
}
int Task1()
{
pkg myPkg;
msg t, aux;
char* filename;
int fdOut;
int res, packNum = 0;
printf("[RECEIVER]Receiver starts.\n");
printf("[RECEIVER]Task index=%d\n", 2);
if (recv_message(&t) < 0) {
perror("[RECEIVER]Error receiving message");
return -1;
}
/* asteptare fisier initializare */
myPkg = *((pkg*)t.payload);
printf("[RECEIVER] Got msg with payload: %s\n", myPkg.payload);
if(myPkg.messageType != TYPE_INIT){
perror("[RECEIVER]Didn't receive init file!\n");
}
sprintf(aux.payload, "ACK(%s)", myPkg.payload);
aux.len = strlen(aux.payload + 1);
send_message(&aux);
/* initializare si deschidere fisier out */
filename = strdup("recv_");
strcat(filename, myPkg.payload);
fdOut = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
/* scriere in fisier pe masura ce se primesc pachetele */
printf("Commence filewriting.\n");
while(1) {
/* curatare msg */
memset(&myPkg, 0, sizeof(pkg));
memset(&t, 0, sizeof(msg));
/* astept mesajul packNum */
do
{
res = recv_message(&t);
myPkg = *((pkg*)t.payload);
}while(myPkg.packNum != packNum);
/* incrementez numarul de ordine al mesajului asteptat */
packNum++;
fflush(stdin);
printf("[RECEIVER]Received package: %i\n", myPkg.packNum);
if (res < 0) {
perror("[RECEIVER]Receive error. Exiting.\n");
return -1;
}
if(myPkg.messageType != TYPE_INFO){
printf("[RECEIVER]Successfully transfered all information.\n");
break;
}
/* tiparire pachet primit */
write(fdOut, myPkg.payload, t.len - 1);
/* tirimitere ACK */
sprintf(aux.payload, "ACK Pachet numarul: (%d)", myPkg.packNum);
aux.len = strlen(aux.payload + 1);
(*(pkg*)aux.payload).packNum = myPkg.packNum;
res = send_message(&aux);
if (res < 0) {
perror("[RECEIVER]Send ACK error. Exiting.\n");
return -1;
}
}
/* trimitere pachet final de confirmare a incheierii transferului */
sprintf((*(pkg*)aux.payload).payload, "ACK Pachet final");
aux.len = strlen(aux.payload + 1);
(*(pkg*)aux.payload).packNum = myPkg.packNum;
res = send_message(&aux);
printf("[RECEIVER]All done.\n");
close(fdOut);
return 0;
}
static int in_session(int s, uint8_t** msg, uint32_t modem_heartbeat_interval, uint32_t router_heartbeat_interval)
{
struct timespec last_recv_time = {0};
struct timespec last_sent_time = {0};
struct timespec now_time = {0};
ssize_t received;
struct timeval timeout = {0};
fd_set readfds;
/* Remember when we started */
clock_gettime(CLOCK_MONOTONIC,&now_time);
last_sent_time = last_recv_time = now_time;
/* Make sure we send and check heartbeats promptly - this is a bit hackish */
timeout.tv_sec = (modem_heartbeat_interval < router_heartbeat_interval ? modem_heartbeat_interval : router_heartbeat_interval);
timeout.tv_usec = (timeout.tv_sec % 1000) * 1000;
timeout.tv_sec /= 1000;
/* Loop forever handling messages */
for (;;)
{
/* Wait for a message */
FD_ZERO(&readfds);
FD_SET(s,&readfds);
if (select(s+1,&readfds,NULL,NULL,&timeout) == -1)
{
printf("Failed to wait for message: %s\n",strerror(errno));
return -1;
}
clock_gettime(CLOCK_MONOTONIC,&now_time);
/* Check for our heartbeat interval */
if (interval_compare(&last_sent_time,&now_time,router_heartbeat_interval) > 0)
{
/* Send out a heartbeat if the 'timer' has expired */
send_heartbeat(s,router_heartbeat_interval);
/* Update the last sent time */
last_sent_time = now_time;
}
if (!FD_ISSET(s,&readfds))
{
/* Timeout */
/* Check Modem heartbeat interval, check for 2 missed intervals */
if (interval_compare(&last_recv_time,&now_time,modem_heartbeat_interval * 2) > 0)
{
printf("No heartbeat from modem within %u seconds, terminating session\n",modem_heartbeat_interval * 2);
return send_session_term(s,DLEP_SC_TIMEDOUT,msg,modem_heartbeat_interval);
}
/* Wait again */
continue;
}
/* Receive a message */
received = recv_message(s,msg);
if (received == -1)
{
printf("Failed to receive from TCP socket: %s\n",strerror(errno));
return -1;
}
else if (received == 0)
{
printf("Modem closed TCP session\n");
return -1;
}
else
{
/* Handle the message */
int r = handle_message(s,msg,received,modem_heartbeat_interval);
if (r != 1)
return r;
}
/* Update the last received time */
last_recv_time = now_time;
}
}
static int term_session(int s, uint8_t** msg, uint32_t modem_heartbeat_interval)
{
struct timespec last_recv_time = {0};
struct timespec now_time = {0};
ssize_t received;
struct timeval timeout = {0};
fd_set readfds;
/* Remember when we started */
clock_gettime(CLOCK_MONOTONIC,&now_time);
last_recv_time = now_time;
/* Make sure we check heartbeats promptly - this is a bit hackish */
timeout.tv_sec = modem_heartbeat_interval / 1000;
timeout.tv_usec = (modem_heartbeat_interval % 1000) * 1000;
/* Loop forever handling messages */
for (;;)
{
/* Wait for a message */
FD_ZERO(&readfds);
FD_SET(s,&readfds);
if (select(s+1,&readfds,NULL,NULL,&timeout) == -1)
{
printf("Failed to wait for message: %s\n",strerror(errno));
return -1;
}
clock_gettime(CLOCK_MONOTONIC,&now_time);
if (!FD_ISSET(s,&readfds))
{
/* Timeout */
/* Check Modem heartbeat interval, check for 2 missed intervals */
if (interval_compare(&last_recv_time,&now_time,modem_heartbeat_interval * 4) > 0)
{
printf("No messages from modem within %u seconds, resetting session\n",modem_heartbeat_interval * 4);
return -1;
}
/* Wait again */
continue;
}
/* Receive a message */
received = recv_message(s,msg);
if (received == -1)
{
printf("Failed to receive from TCP socket: %s\n",strerror(errno));
return -1;
}
else if (received == 0)
{
printf("Modem closed TCP session\n");
return -1;
}
else
{
/* Handle the message */
int r = 0; /* TODO: handle_message(s,msg,received); */
if (r != 1)
return r;
}
/* Update the last received time */
last_recv_time = now_time;
}
}
int session(const struct sockaddr* modem_address, socklen_t modem_address_length, uint32_t router_heartbeat_interval)
{
int ret = -1;
char str_address[FORMATADDRESS_LEN] = {0};
/* First we must initialise, RFC 8175 section 7.2 */
int s = socket(modem_address->sa_family,SOCK_STREAM,0);
if (s == -1)
{
printf("Failed to create socket: %s\n",strerror(errno));
return -1;
}
printf("Connecting to modem at %s\n",formatAddress(modem_address,str_address,sizeof(str_address)));
/* Connect to the modem */
if (connect(s,modem_address,modem_address_length) == -1)
{
printf("Failed to connect socket: %s\n",strerror(errno));
}
else if (send_session_init_message(s,router_heartbeat_interval))
{
uint8_t* msg = NULL;
ssize_t received;
printf("Waiting for Session Initialization Response message\n");
/* Receive a Session Initialization Response message */
received = recv_message(s,&msg);
if (received == -1)
printf("Failed to receive from TCP socket: %s\n",strerror(errno));
else if (received == 0)
printf("Modem disconnected TCP session\n");
else
{
printf("Received possible Session Initialization Response message (%u bytes)\n",(unsigned int)received);
/* Check it's a valid Session Initialization Response message */
if (check_session_init_resp_message(msg,received) == DLEP_SC_SUCCESS)
{
uint32_t modem_heartbeat_interval = 60000;
enum dlep_status_code init_sc = DLEP_SC_SUCCESS;
enum dlep_status_code sc = parse_session_init_resp_message(msg+4,received-4,&modem_heartbeat_interval,&init_sc);
if (sc != DLEP_SC_SUCCESS)
{
send_session_term(s,sc,&msg,modem_heartbeat_interval);
}
else if (init_sc != DLEP_SC_SUCCESS)
{
printf("Non-zero Status data item in Session Initialization Response message: %u, Terminating\n",init_sc);
ret = send_session_term(s,DLEP_SC_SHUTDOWN,&msg,modem_heartbeat_interval);
}
else
{
printf("Moving to 'in-session' state\n");
ret = in_session(s,&msg,modem_heartbeat_interval,router_heartbeat_interval);
}
}
}
free(msg);
}
close(s);
return ret;
}
int main(int argc, char *argv[])
{
int task_index;
msg t;
my_sum s;
int fw, filesize, dimF;
char filename[SUMSIZE];
char aux[SUMSIZE];
int check;
task_index = atoi(argv[1]);
printf("[RECEIVER] Receiver starts.\n");
printf("[RECEIVER] Task index=%d\n", task_index);
init(HOST, PORT2);
s.count = -23;
// Wait for filename
while (s.count != -3){
memset(t.payload, 0, sizeof(t.payload));
if (recv_message(&t) < 0) {
perror("[RECEIVER] Receive message");
return -1;
}
s = *((my_sum*) t.payload);
check = checksum(s.payload, (t.len - 2*sizeof(int)), s.count);
if (check == s.checksum)
printf("[RECEIVER] Received count %d\n", s.count);
else
s.count = -23;
}
// Extract filename
memcpy(aux, s.payload, t.len - 2*sizeof(int));
strcat(filename, "recv_");
strcat(filename, aux);
printf("[RECEIVER] Filename: %s\n", filename);
// Send ACK for filename
memset(t.payload, 0, sizeof(t.payload));
memset(s.payload, 0, sizeof(s.payload));
s.count = -3;
t.len = strlen(s.payload) + sizeof(int);
memcpy(t.payload, &s, t.len);
send_message(&t);
// Wait for filesize
while (s.count != -2){
memset(t.payload, 0, sizeof(t.payload));
if (recv_message(&t) < 0) {
perror("Receive message");
return -1;
}
s = *((my_sum*) t.payload);
check = checksum(s.payload, (t.len - 2*sizeof(int)), s.count);
if (check == s.checksum)
printf("[RECEIVER] Received count %d\n", s.count);
else
s.count = -23;
}
memcpy(&filesize, s.payload, sizeof(int));
printf("[RECEIVER] Filesize: %d\n", filesize);
// Send ACK for filesize
memset(t.payload, 0, sizeof(t.payload));
memset(s.payload, 0, sizeof(s.payload));
t.len = strlen(s.payload) + sizeof(int);
memcpy(t.payload, &s, t.len);
send_message(&t);
// Wait for dimF
while (s.count != -1){
memset(t.payload, 0, sizeof(t.payload));
if (recv_message(&t) < 0) {
perror("Receive message");
return -1;
}
s = *((my_sum*) t.payload);
check = checksum(s.payload, (t.len - 2*sizeof(int)), s.count);
if (check == s.checksum)
printf("[RECEIVER] Received count %d\n", s.count);
else
s.count = -23;
}
memcpy(&dimF, s.payload, sizeof(int));
printf("[RECEIVER] Window size: %d\n", dimF);
// Send ACK for dimF
memset(t.payload, 0, sizeof(t.payload));
memset(s.payload, 0, sizeof(s.payload));
t.len = strlen(s.payload) + sizeof(int);
memcpy(t.payload, &s, t.len);
send_message(&t);
fw = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0644);
if (task_index == 0)
receive_t0(fw, filesize);
if (task_index == 1)
receive_t1(fw, filesize);
if (task_index == 2)
receive_t2(fw, filesize, dimF);
if (task_index == 3)
receive_t3(fw, filesize, dimF);
close (fw);
return 0;
}
void *
handle_client(void * arg)
{
struct thread_data_t * datum = (struct thread_data_t *)(arg);
/* Fetch the ID from the argument */
#ifndef NDEBUG
fprintf(stderr, "[thread %lu] INFO: worker started\n", datum->id);
#endif
/* Worker thread signal handling is unique */
sigaction(SIGUSR1, datum->signal_action, NULL);
sigaction(SIGUSR2, datum->signal_action, NULL);
/* As long as possible, grab up whatever connection is available */
while (!session_data.caught_signal && !datum->caught_signal) {
/* Ensure only one worker accepts the next client */
gcry_pthread_mutex_lock((void **)(&session_data.accept_mutex));
datum->sock = accept(session_data.sock,
(struct sockaddr *)(&datum->remote_addr),
&datum->remote_addr_len);
gcry_pthread_mutex_unlock((void **)(&session_data.accept_mutex));
if (datum->sock >= 0) {
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: worker connected to client\n",
datum->id);
#endif
/* Receive a "hello" message from the client */
recv_message(&datum->buffet, datum->sock);
/* Decrypt it with the default key */
decrypt_message(&datum->buffet, keystore.key);
/* Verify it is an authentication request */
if (strncmp(datum->buffet.tbuffer,
AUTH_CHECK_MSG, sizeof(AUTH_CHECK_MSG))) {
/* Respond with nonce (misdirection) */
gcry_create_nonce(datum->buffet.pbuffer, MAX_COMMAND_LENGTH);
encrypt_message(&datum->buffet, keystore.key);
send_message(&datum->buffet, datum->sock);
} else {
/* Request a session key */
gcry_pthread_mutex_lock((void **)(&session_data.keystore_mutex));
#ifndef NDEBUG
print_keystore(stderr, "before request");
#endif
request_key(&datum->credentials.key);
#ifndef NDEBUG
print_keystore(stderr, "after request");
#endif
gcry_pthread_mutex_unlock((void **)(&session_data.keystore_mutex));
/* Encrypted it using the default key */
salt_and_pepper((char *)(datum->credentials.key), NULL,
&datum->buffet);
encrypt_message(&datum->buffet, keystore.key);
send_message(&datum->buffet, datum->sock);
clear_buffet(&datum->buffet);
/* Repeatedly poll for message streams */
while (handle_stream(datum) == BANKING_SUCCESS);
/* Revoke the session key */
gcry_pthread_mutex_lock((void **)(&session_data.keystore_mutex));
#ifndef NDEBUG
print_keystore(stderr, "before revoke");
#endif
revoke_key(&datum->credentials.key);
#ifndef NDEBUG
print_keystore(stderr, "after revoke");
#endif
gcry_pthread_mutex_unlock((void **)(&session_data.keystore_mutex));
}
/* Cleanup (disconnect) */
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: worker disconnected from client\n",
datum->id);
#endif
clear_buffet(&datum->buffet);
destroy_socket(datum->sock);
datum->sock = BANKING_FAILURE;
} else {
fprintf(stderr,
"[thread %lu] ERROR: worker unable to connect\n",
datum->id);
}
}
/* Teardown */
handle_interruption(0);
return NULL;
}
/*! \brief Handle a message stream from a client */
int
handle_stream(struct thread_data_t * datum) {
int i;
handle_t hdl;
char msg[MAX_COMMAND_LENGTH], * args;
/* The initial message is always an authentication request */
recv_message(&datum->buffet, datum->sock);
decrypt_message(&datum->buffet, datum->credentials.key);
if (strncmp(datum->buffet.tbuffer,
AUTH_CHECK_MSG, sizeof(AUTH_CHECK_MSG))) {
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: malformed authentication message\n",
datum->id);
#endif
/* Respond with a "mumble" (nonce) */
gcry_create_nonce(datum->buffet.pbuffer, MAX_COMMAND_LENGTH);
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
return BANKING_FAILURE;
}
/* Turn around the buffer and toss it back */
for (i = 0; i < MAX_COMMAND_LENGTH; ++i) {
datum->buffet.pbuffer[i] =
datum->buffet.tbuffer[MAX_COMMAND_LENGTH - 1 - i];
}
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
clear_buffet(&datum->buffet);
#ifndef NDEBUG
fprintf(stderr,
"[thread %lu] INFO: authentication successful\n",
datum->id);
#endif
/* Read the actual command */
recv_message(&datum->buffet, datum->sock);
decrypt_message(&datum->buffet, datum->credentials.key);
/* Copy the command into a buffer so more can be received */
strncpy(msg, datum->buffet.tbuffer, MAX_COMMAND_LENGTH);
#ifndef NDEBUG
/* Local echo for all received messages */
fprintf(stderr,
"[thread %lu] INFO: worker received message:\n",
datum->id);
hexdump(stderr, (unsigned char *)(msg), MAX_COMMAND_LENGTH);
#endif
/* Disconnect from any client that issues malformed commands */
if (fetch_handle(msg, &hdl, &args)) {
/* Respond with a "mumble" (nonce) */
gcry_create_nonce(datum->buffet.pbuffer, MAX_COMMAND_LENGTH);
encrypt_message(&datum->buffet, datum->credentials.key);
send_message(&datum->buffet, datum->sock);
clear_buffet(&datum->buffet);
return BANKING_FAILURE;
}
/* We are signaled by failed handlers */
datum->caught_signal = hdl(datum, args);
clear_buffet(&datum->buffet);
return BANKING_SUCCESS;
}
static int sync_meta(csiebox_server *server, int conn_fd, csiebox_protocol_meta *meta)/*{{{*/
{
char full_path[PATH_MAX];
recv_message(conn_fd, full_path, sizeof(full_path));
// make a short path
char *client_path = make_path(full_path);
char *cur_dir = get_user_homedir(server, server->client[conn_fd]);
if (chdir(cur_dir) == -1) {
fprintf(stderr, "change to user directory error\n");
return 0;
}
// start to traverse
int file_check = 0;
char *object = strtok(client_path, "/");
while(object != NULL){
strcat(cur_dir, "/");
strcat(cur_dir, object);
struct stat object_stat;
memset(&object_stat, 0, sizeof(object_stat));
int open_success = lstat(cur_dir, &object_stat);
// if file not exist
if (open_success == -1){
if (S_ISDIR(meta->message.body.stat.st_mode)) {
mkdir(cur_dir, meta->message.body.stat.st_mode);
fprintf(stderr, "sync meta : create dir\n");
// dir utime
struct utimbuf meta_time;
memset(&meta_time, 0, sizeof(meta_time));
meta_time.actime = meta->message.body.stat.st_atime;
meta_time.modtime = meta->message.body.stat.st_mtime;
utime(cur_dir, &meta_time);
fprintf(stderr, "create dir\n");
}
if (S_ISREG(meta->message.body.stat.st_mode)) {
int fd = creat(cur_dir, meta->message.body.stat.st_mode);
// file utime
struct utimbuf meta_time;
memset(&meta_time, 0, sizeof(meta_time));
meta_time.actime = meta->message.body.stat.st_atime;
meta_time.modtime = meta->message.body.stat.st_mtime;
utime(cur_dir, &meta_time);
fprintf(stderr, "sync meta : create file\n");
close(fd);
file_check = 1;
}
if (S_ISLNK(meta->message.body.stat.st_mode)) {
fprintf(stderr, "sync meta : is symbolic link\n");
file_check = 1;
}
object = strtok(NULL, "/");
}
// file exist
else {
// is directory
if (S_ISDIR(object_stat.st_mode)){
if (chdir(cur_dir) == -1) {
fprintf(stderr, "chdir error\n");
return 0;
}
}
else {
// is file
// file chmod
chmod(cur_dir, meta->message.body.stat.st_mode);
chown(cur_dir, meta->message.body.stat.st_uid, meta->message.body.stat.st_gid);
// check if is same
uint8_t content_hash[MD5_DIGEST_LENGTH];
memset(content_hash, 0, sizeof(content_hash));
md5_file(cur_dir, content_hash);
if (memcmp(content_hash, meta->message.body.hash, MD5_DIGEST_LENGTH) != 0) file_check = 1;
// file utime
struct utimbuf meta_time;
memset(&meta_time, 0, sizeof(meta_time));
meta_time.actime = meta->message.body.stat.st_atime;
meta_time.modtime = meta->message.body.stat.st_mtime;
utime(cur_dir, &meta_time);
}
object = strtok(NULL, "/");
// dir chmod
if (object == NULL) {
chmod(cur_dir, meta->message.body.stat.st_mode);
chown(cur_dir, meta->message.body.stat.st_uid, meta->message.body.stat.st_gid);
struct utimbuf meta_time;
// dir utime
memset(&meta_time, 0, sizeof(meta_time));
meta_time.actime = meta->message.body.stat.st_atime;
meta_time.modtime = meta->message.body.stat.st_mtime;
utime(cur_dir, &meta_time);
}
}
}
// send back message
csiebox_protocol_header header;
memset(&header, 0, sizeof(header));
header.res.magic = CSIEBOX_PROTOCOL_MAGIC_RES;
header.res.op = CSIEBOX_PROTOCOL_OP_SYNC_META;
header.res.status = (file_check == 1)? CSIEBOX_PROTOCOL_STATUS_MORE : CSIEBOX_PROTOCOL_STATUS_OK;
header.res.datalen = 0;
send_message(conn_fd, &header, sizeof(header));
fprintf(stderr, "sync meta : success\n");
return 1;
}/*}}}*/
