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; }/*}}}*/