use std::collections::{HashMap, HashSet};
use crate::segment::bitfield_util;
pub struct PeerSessionResource {
bitfield: Vec<u8>,
pub bitfield_length: usize,
piece_length: u32,
total_length: u64,
num_pieces: u32,
fast_extension_enabled: bool,
peer_allowed_index_set: HashSet<u32>,
am_allowed_index_set: HashSet<u32>,
extended_messaging_enabled: bool,
extension_registry: HashMap<String, u8>,
dht_enabled: bool,
choking_required: bool,
opt_unchoking: bool,
snubbing: bool,
}
impl PeerSessionResource {
pub fn new(piece_length: u32, total_length: u64) -> Self {
let num_pieces = if piece_length == 0 || total_length == 0 {
0
} else {
total_length.div_ceil(piece_length as u64) as u32
};
let bitfield_length = (num_pieces as usize).div_ceil(8);
Self {
bitfield: vec![0u8; bitfield_length],
bitfield_length,
piece_length,
total_length,
num_pieces,
fast_extension_enabled: false,
peer_allowed_index_set: HashSet::new(),
am_allowed_index_set: HashSet::new(),
extended_messaging_enabled: false,
extension_registry: HashMap::new(),
dht_enabled: false,
choking_required: true,
opt_unchoking: false,
snubbing: false,
}
}
pub fn has_piece(&self, index: usize) -> bool {
bitfield_util::test_bit(&self.bitfield, self.num_pieces as usize, index)
}
pub fn set_bitfield(&mut self, bitfield: &[u8]) -> Vec<u8> {
let old = self.bitfield.clone();
let copy_len = std::cmp::min(bitfield.len(), self.bitfield.len());
self.bitfield[..copy_len].copy_from_slice(&bitfield[..copy_len]);
self.bitfield[copy_len..].fill(0);
old
}
pub fn update_bitfield(&mut self, index: usize, operation: i32) {
if index >= self.num_pieces as usize {
return;
}
let byte = index / 8;
let bit = 7 - (index % 8);
if byte >= self.bitfield.len() {
return;
}
if operation == 1 {
self.bitfield[byte] |= 1 << bit;
} else {
self.bitfield[byte] &= !(1 << bit);
}
}
pub fn set_all_bitfield(&mut self) {
self.bitfield.fill(0xFF);
let remaining = (self.num_pieces as usize) % 8;
if remaining != 0 {
let extra = 8 - remaining;
if let Some(last) = self.bitfield.last_mut() {
*last &= !((1u8 << extra) - 1);
}
}
}
pub fn mark_seeder(&mut self) {
self.set_all_bitfield();
}
pub fn clear_bitfield(&mut self) {
self.bitfield.fill(0);
}
pub fn is_seeder(&self) -> bool {
let mut count = 0usize;
for &byte in &self.bitfield {
count += byte.count_ones() as usize;
}
let remaining = (self.num_pieces as usize) % 8;
if remaining != 0 && !self.bitfield.is_empty() {
let extra = 8 - remaining;
if let Some(&last) = self.bitfield.last() {
let trailing = (last & ((1u8 << extra) - 1)).count_ones() as usize;
count -= trailing;
}
}
count == self.num_pieces as usize
}
pub fn bitfield(&self) -> &[u8] {
&self.bitfield
}
pub fn reconfigure(&mut self, piece_length: u32, total_length: u64) {
let num_pieces = if piece_length == 0 || total_length == 0 {
0
} else {
total_length.div_ceil(piece_length as u64) as u32
};
let bitfield_length = (num_pieces as usize).div_ceil(8);
self.bitfield.resize(bitfield_length, 0);
self.bitfield_length = bitfield_length;
self.piece_length = piece_length;
self.total_length = total_length;
self.num_pieces = num_pieces;
}
pub fn num_pieces(&self) -> u32 {
self.num_pieces
}
pub fn piece_length(&self) -> u32 {
self.piece_length
}
pub fn total_length(&self) -> u64 {
self.total_length
}
pub fn set_fast_extension_enabled(&mut self, enabled: bool) {
self.fast_extension_enabled = enabled;
}
pub fn is_fast_extension_enabled(&self) -> bool {
self.fast_extension_enabled
}
pub fn add_peer_allowed_index(&mut self, index: u32) {
self.peer_allowed_index_set.insert(index);
}
pub fn is_in_peer_allowed_index_set(&self, index: u32) -> bool {
self.peer_allowed_index_set.contains(&index)
}
pub fn add_am_allowed_index(&mut self, index: u32) {
self.am_allowed_index_set.insert(index);
}
pub fn is_in_am_allowed_index_set(&self, index: u32) -> bool {
self.am_allowed_index_set.contains(&index)
}
pub fn set_extended_messaging_enabled(&mut self, enabled: bool) {
self.extended_messaging_enabled = enabled;
}
pub fn is_extended_messaging_enabled(&self) -> bool {
self.extended_messaging_enabled
}
pub fn add_extension(&mut self, key: &str, id: u8) {
self.extension_registry.insert(key.to_string(), id);
}
pub fn get_extension_message_id(&self, key: &str) -> Option<u8> {
self.extension_registry.get(key).copied()
}
pub fn get_extension_name(&self, id: u8) -> Option<&str> {
self.extension_registry
.iter()
.find(|&(_, &v)| v == id)
.map(|(k, _)| k.as_str())
}
pub fn set_dht_enabled(&mut self, enabled: bool) {
self.dht_enabled = enabled;
}
pub fn is_dht_enabled(&self) -> bool {
self.dht_enabled
}
pub fn set_choking_required(&mut self, required: bool) {
self.choking_required = required;
}
pub fn choking_required(&self) -> bool {
self.choking_required
}
pub fn set_opt_unchoking(&mut self, enabled: bool) {
self.opt_unchoking = enabled;
}
pub fn opt_unchoking(&self) -> bool {
self.opt_unchoking
}
pub fn set_snubbing(&mut self, snubbing: bool) {
self.snubbing = snubbing;
}
pub fn snubbing(&self) -> bool {
self.snubbing
}
pub fn should_be_choking(&self) -> bool {
self.choking_required && !self.opt_unchoking
}
pub fn count_outstanding_upload(&self) -> usize {
0
}
}