diff --git a/client-gui/src/gui_app.rs b/client-gui/src/gui_app.rs index cc85b5d..b271593 100644 --- a/client-gui/src/gui_app.rs +++ b/client-gui/src/gui_app.rs @@ -240,6 +240,7 @@ impl eframe::App for P2PClientApp { if let Some(addr) = &self.active_peer { if let Some(roottree) = self.loaded_fs.get(addr) { if let Some(root) = roottree.data.get(&hash) { + self.current_downloading_file_map.root = hash; self.root_downloading_file = name; let _ = self .current_downloading_file_map @@ -278,17 +279,46 @@ impl eframe::App for P2PClientApp { } _ => {} } - - if let Some(total) = self.current_total_chunks { - // recompute received (safer than incrementing) - let received = total.saturating_sub(self.remaining_chunks.len()); - self.current_received_chunks = received; - } - + println!("remaining chunks size: {}", self.remaining_chunks.len()); if self.remaining_chunks.is_empty() { - self.current_total_chunks = None; - self.current_received_chunks = 0; - println!("bigfile téléchargé"); + let file = OpenOptions::new().append(true).create(true).open( + "./Download/".to_string() + + &remove_null_bytes(&self.root_downloading_file.clone()), + ); + + if let Some(current) = self + .current_downloading_file_map + .data + .get(&self.current_downloading_file_map.root) + { + match file { + Ok(mut fileok) => { + big_or_chunk_to_file( + &self.current_downloading_file_map, + current, + &mut fileok, + ); + } + Err(e) => { + eprintln!("error creaation file: {}", e); + } + } + } else { + eprintln!("error root absent"); + } + println!("bigfile téléchargé {}", self.root_downloading_file); + + if let Some(total) = self.current_total_chunks { + // recompute received (safer than incrementing) + let received = total.saturating_sub(self.remaining_chunks.len()); + self.current_received_chunks = received; + } + + if self.remaining_chunks.is_empty() { + self.current_total_chunks = None; + self.current_received_chunks = 0; + println!("bigfile téléchargé"); + } } } NetworkEvent::Success(msg, peer_username) => { diff --git a/client-network/src/data.rs b/client-network/src/data.rs index 7daf4fb..4479ffa 100644 --- a/client-network/src/data.rs +++ b/client-network/src/data.rs @@ -473,8 +473,15 @@ pub fn big_or_chunk_to_file(tree: &MerkleTree, node: &MerkleNode, file: &mut Fil } } MerkleNode::Chunk(chunk) => { - println!("wrote data"); - let _ = file.write_all(&chunk.data); + if !chunk.data.is_empty() { + // Enlève le premier élément + let mut data = chunk.data.clone(); // Clone pour éviter de modifier l'original + data.remove(0); // Enlève le premier élément + println!("wrote data {:?}", data); + let _ = file.write(&data); + } else { + println!("chunk.data is empty, nothing to write"); + } } _ => { println!("invalid type of file"); diff --git a/client-network/src/datum_parsing.rs b/client-network/src/datum_parsing.rs index 13aca63..3797527 100644 --- a/client-network/src/datum_parsing.rs +++ b/client-network/src/datum_parsing.rs @@ -11,84 +11,103 @@ pub fn parse_received_datum( datum_length: usize, ) -> Option<([u8; 32], MerkleNode)> { let hash_name: [u8; 32] = recevied_datum[..32].try_into().expect("error"); - let value = &recevied_datum[32..recevied_datum.len()]; + let value = &recevied_datum[32..datum_length]; let value_slice = value.to_vec(); println!("valueslice: {:?}, {}", value_slice, value_slice.len()); - let datum_type = value_slice[0]; - match datum_type { - CHUNK => Some(( - hash_name, - MerkleNode::Chunk(crate::ChunkNode { data: value_slice }), - )), - DIRECTORY => { - let mut dir_entries = Vec::new(); - let mut offset = 1 as usize; - for i in 0..((value_slice.len() - 1) / 64) as u8 { - offset = (1 + 64 * i as usize) as usize; - println!("offset:{}, i:{}", offset, i); - let name = &value_slice[offset..offset + 32]; - let mut hash = [0u8; 32]; - hash.copy_from_slice(&value_slice[offset + 32..offset + 64]); - let dp_name = String::from_utf8(name.to_vec()).expect("err"); - println!("name:{}", dp_name); - // envoyer un datum request - dir_entries.push(DirectoryEntry { - filename: name.try_into().expect("incorrect size"), - content_hash: hash, - }); - } + println!( + "((value_slice.len() - 1) / 32) {} ", + ((value_slice.len() - 1) / 32) + ); + // Créer une instance de Sha256 + let mut hasher = Sha256::new(); - let current = DirectoryNode::new(dir_entries); - match current { - Ok(current_node) => Some((hash_name, MerkleNode::Directory(current_node))), - Err(e) => { - println!("{}", e); - None - } - } - } - BIG => { - let mut bigdir_entries: Vec = Vec::new(); - let mut offset = 1 as usize; - for i in 0..((value_slice.len() - 1) / 32) as u8 { - offset = (1 + 32 * i as usize) as usize; - println!("offset:{}, i:{}", offset, i); - let hash = &value_slice[offset..offset + 32]; + // Alimenter le hasher avec les données + hasher.update(value_slice.clone()); - // envoyer un datum request - bigdir_entries.push(hash.try_into().expect("incorrect size")); - } - - println!("its a BIG bro"); - Some(( + // Obtention du résultat + let result = hasher.finalize(); + if result.to_vec() != hash_name.to_vec() { + println!("{:?},{:?}", result.to_vec(), hash_name.to_vec()); + None + } else { + println!("hashes equals!"); + let datum_type = value_slice[0]; + match datum_type { + CHUNK => Some(( hash_name, - MerkleNode::Big(crate::BigNode { - children_hashes: bigdir_entries, - }), - )) - } - BIGDIRECTORY => { - let mut bigdir_entries: Vec = Vec::new(); - let mut offset = 1 as usize; - for i in 0..((value_slice.len() - 1) / 32) as u8 { - offset = (1 + 32 * i as usize) as usize; - println!("offset:{}, i:{}", offset, i); - let hash = &value_slice[offset..offset + 32]; + MerkleNode::Chunk(crate::ChunkNode { data: value_slice }), + )), + DIRECTORY => { + let mut dir_entries = Vec::new(); + let mut offset = 1 as usize; + for i in 0..((value_slice.len() - 1) / 64) as u8 { + offset = (1 + 64 * i as usize) as usize; + println!("offset:{}, i:{}", offset, i); + let name = &value_slice[offset..offset + 32]; + let mut hash = [0u8; 32]; + hash.copy_from_slice(&value_slice[offset + 32..offset + 64]); + let dp_name = String::from_utf8(name.to_vec()).expect("err"); + println!("name:{}", dp_name); - // envoyer un datum request - bigdir_entries.push(hash.try_into().expect("incorrect size")); - } + // envoyer un datum request + dir_entries.push(DirectoryEntry { + filename: name.try_into().expect("incorrect size"), + content_hash: hash, + }); + } - let current = BigDirectoryNode::new(bigdir_entries); - match current { - Ok(current_node) => Some((hash_name, MerkleNode::BigDirectory(current_node))), - Err(e) => { - println!("{}", e); - None + let current = DirectoryNode::new(dir_entries); + match current { + Ok(current_node) => Some((hash_name, MerkleNode::Directory(current_node))), + Err(e) => { + println!("{}", e); + None + } } } + BIG => { + let mut bigdir_entries: Vec = Vec::new(); + let mut offset = 1 as usize; + for i in 0..((value_slice.len() - 1) / 32) as u8 { + offset = (1 + 32 * i as usize) as usize; + println!("offset:{}, i:{}", offset, i); + let hash = &value_slice[offset..offset + 32]; + + // envoyer un datum request + bigdir_entries.push(hash.try_into().expect("incorrect size")); + } + + println!("its a BIG bro"); + Some(( + hash_name, + MerkleNode::Big(crate::BigNode { + children_hashes: bigdir_entries, + }), + )) + } + BIGDIRECTORY => { + let mut bigdir_entries: Vec = Vec::new(); + let mut offset = 1 as usize; + for i in 0..((value_slice.len() - 1) / 32) as u8 { + offset = (1 + 32 * i as usize) as usize; + println!("offset:{}, i:{}", offset, i); + let hash = &value_slice[offset..offset + 32]; + + // envoyer un datum request + bigdir_entries.push(hash.try_into().expect("incorrect size")); + } + + let current = BigDirectoryNode::new(bigdir_entries); + match current { + Ok(current_node) => Some((hash_name, MerkleNode::BigDirectory(current_node))), + Err(e) => { + println!("{}", e); + None + } + } + } + _ => None, } - _ => None, } } diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index a5b928f..6cf1057 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -73,7 +73,7 @@ impl P2PSharedData { let mut threads = Vec::new(); - let senders = MultipleSenders::new(1, &shared_socket, cmd_tx, &mut threads); + let senders = MultipleSenders::new(5, &shared_socket, cmd_tx, &mut threads); let shared_senders = Arc::new(senders); let server_name = Arc::new(Mutex::new("".to_string())); let server_address = Arc::new(Mutex::new("".to_string())); diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index c10530c..3365e0a 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -370,14 +370,11 @@ pub fn parse_message( // envoyer la root request let _ = &guard.remove_entry(&id); println!("message {} retiré de la liste", id); - - let rootrequest = construct_message( - ROOTREQUEST, - Vec::new(), - generate_id(), - crypto_pair, - ); - //&guard.insert(, v) + let new_id = generate_id(); + let rootrequest = + construct_message(ROOTREQUEST, Vec::new(), new_id, crypto_pair); + let _ = &guard.insert(new_id, EventType::RootRequest); + println!("root requesst sent"); return rootrequest; } EventType::Hello => { @@ -392,6 +389,7 @@ pub fn parse_message( } ROOTREPLY => { // recuperer le pseudo du peers ayant repondu + println!("root reply received"); let peers_exist = handhsake_history.get_peer_info_ip(ip.to_string()); match peers_exist { Some(peerinfo) => { @@ -429,7 +427,9 @@ pub fn parse_message( constructed_message = datumreqest; guard.insert(new_id, EventType::DatumRequest); } - _ => {} + _ => { + println!("event not prensent"); + } } } None => {} @@ -468,7 +468,6 @@ pub fn parse_message( } } EventType::DatumRequestBig => { - let _ = &guard.remove_entry(&id); println!("message {} retiré de la liste", id); let received_length = u16::from_be_bytes( received_message[TYPE..LENGTH] @@ -481,6 +480,7 @@ pub fn parse_message( parse_received_datum(received_datum.to_vec(), received_length as usize); match parsed_node { Some(tuple) => { + let _ = &guard.remove_entry(&id); let _ = cmd_tx.send(NetworkEvent::DataReceived( tuple.0, tuple.1, @@ -488,7 +488,9 @@ pub fn parse_message( )); println!("datareceived event sent"); } - None => {} + None => { + println!("message corrompu, nouvelle tentative"); + } } } _ => {} diff --git a/client-network/src/messages_channels.rs b/client-network/src/messages_channels.rs index 9dd6285..d7da7b6 100644 --- a/client-network/src/messages_channels.rs +++ b/client-network/src/messages_channels.rs @@ -234,7 +234,8 @@ pub fn start_retry_thread( ); let base: u64 = 2; - let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds + // let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds + let backoff = 1; let newretry = RetryMessage { next_try: SystemTime::now() .duration_since(UNIX_EPOCH) @@ -272,7 +273,7 @@ pub fn start_receving_thread( let messages_received_clone = shared_data.messages_received(); let servername_clone = shared_data.servername(); let thread = thread::spawn(move || { - let mut buf = [0u8; 1024]; + let mut buf = [0u8; 1500]; loop { match sock_clone.recv_from(&mut buf) { Ok((amt, src)) => { diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index a94c11e..12fb34f 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -51,6 +51,7 @@ pub fn parse_addresses(input: &String) -> Vec { /// /// registers the IP addresses by sending a Hello request to the server. /// + pub async fn perform_handshake( sd: &P2PSharedData, username: String, @@ -139,36 +140,3 @@ pub async fn perform_handshake( //TODO return true; } - -#[cfg(test)] -mod tests { - - /*/// - /// does the procedure to register with the server - /// - #[tokio::test] - async fn registering_with_server() { - let username = String::from("gameixtreize"); - let server_uri = String::from("https://jch.irif.fr:8443"); - let crypto_pair = CryptographicSignature::new(username); - if let Err(e) = register_with_the_server(crypto_pair, server_uri).await { - eprintln!("Error during registration: {}", e); - } - }*/ - - /*/// - /// retreives the socket address of a given peer - /// - #[tokio::test] - async fn retreive_socket_addr() { - let username = String::from("ipjkndqfshjldfsjlbsdfjhhj"); - match get_socket_address(username).await { - Ok(body) => { - println!("{:?}", body); - } - Err(e) => { - eprintln!("Erreur HTTP: {}", e); - } - } - }*/ -}