bob/p2p
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

bigfix #5

Merged
wikano merged 4 commits from bigfix into master 2026-01-25 02:46:53 +00:00
Conversation 0 Commits 4 Files Changed 7 +91 -79
4 changed files with 91 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 79f523be48 - Show all commits

16
client-gui/src/gui_app.rs
View File

@@ -262,6 +262,7 @@ impl eframe::App for P2PClientApp {
if let Some(addr) = &self.active_peer { if let Some(addr) = &self.active_peer {
if let Some(roottree) = self.loaded_fs.get(addr) { if let Some(roottree) = self.loaded_fs.get(addr) {
if let Some(root) = roottree.data.get(&hash) { if let Some(root) = roottree.data.get(&hash) {
self.current_downloading_file_map.root = hash;
self.root_downloading_file = name; self.root_downloading_file = name;
let _ = self let _ = self
.current_downloading_file_map .current_downloading_file_map
@@ -299,11 +300,12 @@ impl eframe::App for P2PClientApp {
} }
_ => {} _ => {}
} }
println!("remaining chunks size: {}", self.remaining_chunks.len());
if self.remaining_chunks.is_empty() { if self.remaining_chunks.is_empty() {
/*let file = OpenOptions::new() let file = OpenOptions::new().append(true).create(true).open(
.append(true) "./Download/".to_string()
.create(true) + &remove_null_bytes(&self.root_downloading_file.clone()),
.open(self.root_downloading_file.clone()); );
if let Some(current) = self if let Some(current) = self
.current_downloading_file_map .current_downloading_file_map
@@ -322,8 +324,10 @@ impl eframe::App for P2PClientApp {
eprintln!("error creaation file: {}", e); eprintln!("error creaation file: {}", e);
} }
} }
}*/ } else {
println!("bigfile téléchargé"); eprintln!("error root absent");
}
println!("bigfile téléchargé {}", self.root_downloading_file);
} }
} }
NetworkEvent::Success(msg, peer_username) => { NetworkEvent::Success(msg, peer_username) => {

145
client-network/src/datum_parsing.rs
View File

@@ -14,81 +14,86 @@ pub fn parse_received_datum(
let value = &recevied_datum[32..recevied_datum.len()]; let value = &recevied_datum[32..recevied_datum.len()];
let value_slice = value.to_vec(); let value_slice = value.to_vec();
println!("valueslice: {:?}, {}", value_slice, value_slice.len()); println!("valueslice: {:?}, {}", value_slice, value_slice.len());
let datum_type = value_slice[0]; let digest = Sha256::digest(&value);
match datum_type { if digest.to_vec() != hash_name.to_vec() {
CHUNK => Some(( None
hash_name, } else {
MerkleNode::Chunk(crate::ChunkNode { data: value_slice }), let datum_type = value_slice[0];
)), match datum_type {
DIRECTORY => { CHUNK => Some((
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,
});
}
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<NodeHash> = 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, hash_name,
MerkleNode::Big(crate::BigNode { MerkleNode::Chunk(crate::ChunkNode { data: value_slice }),
children_hashes: bigdir_entries, )),
}), DIRECTORY => {
)) let mut dir_entries = Vec::new();
} let mut offset = 1 as usize;
BIGDIRECTORY => { for i in 0..((value_slice.len() - 1) / 64) as u8 {
let mut bigdir_entries: Vec<NodeHash> = Vec::new(); offset = (1 + 64 * i as usize) as usize;
let mut offset = 1 as usize; println!("offset:{}, i:{}", offset, i);
for i in 0..((value_slice.len() - 1) / 32) as u8 { let name = &value_slice[offset..offset + 32];
offset = (1 + 32 * i as usize) as usize; let mut hash = [0u8; 32];
println!("offset:{}, i:{}", offset, i); hash.copy_from_slice(&value_slice[offset + 32..offset + 64]);
let hash = &value_slice[offset..offset + 32]; let dp_name = String::from_utf8(name.to_vec()).expect("err");
println!("name:{}", dp_name);
// envoyer un datum request // envoyer un datum request
bigdir_entries.push(hash.try_into().expect("incorrect size")); dir_entries.push(DirectoryEntry {
} filename: name.try_into().expect("incorrect size"),
content_hash: hash,
});
}
let current = BigDirectoryNode::new(bigdir_entries); let current = DirectoryNode::new(dir_entries);
match current { match current {
Ok(current_node) => Some((hash_name, MerkleNode::BigDirectory(current_node))), Ok(current_node) => Some((hash_name, MerkleNode::Directory(current_node))),
Err(e) => { Err(e) => {
println!("{}", e); println!("{}", e);
None None
}
} }
} }
BIG => {
let mut bigdir_entries: Vec<NodeHash> = 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<NodeHash> = 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,
} }
} }

6
client-network/src/message_handling.rs
View File

@@ -468,7 +468,6 @@ pub fn parse_message(
} }
} }
EventType::DatumRequestBig => { EventType::DatumRequestBig => {
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id); println!("message {} retiré de la liste", id);
let received_length = u16::from_be_bytes( let received_length = u16::from_be_bytes(
received_message[TYPE..LENGTH] received_message[TYPE..LENGTH]
@@ -481,6 +480,7 @@ pub fn parse_message(
parse_received_datum(received_datum.to_vec(), received_length as usize); parse_received_datum(received_datum.to_vec(), received_length as usize);
match parsed_node { match parsed_node {
Some(tuple) => { Some(tuple) => {
let _ = &guard.remove_entry(&id);
let _ = cmd_tx.send(NetworkEvent::DataReceived( let _ = cmd_tx.send(NetworkEvent::DataReceived(
tuple.0, tuple.0,
tuple.1, tuple.1,
@@ -488,7 +488,9 @@ pub fn parse_message(
)); ));
println!("datareceived event sent"); println!("datareceived event sent");
} }
None => {} None => {
println!("message corrompu, nouvelle tentative");
}
} }
} }
_ => {} _ => {}

3
client-network/src/messages_channels.rs
View File

@@ -234,7 +234,8 @@ pub fn start_retry_thread(
); );
let base: u64 = 2; 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 { let newretry = RetryMessage {
next_try: SystemTime::now() next_try: SystemTime::now()
.duration_since(UNIX_EPOCH) .duration_since(UNIX_EPOCH)