This changes the definition of FromBecode to

trait FromBencode {
    type Err;
    fn from_bencode(bencode: &Bencode) -> Result<Self, Self::Err>;
}

allowing the from_bencode methods to say why they weren't able to convert from bencode. It also adds error types for the various different FromBencode implementations.

I just added this to my Cargo.toml. However on cargo build the compiler fails with this message (after numerous warnings):

src/bencode.rs:672:5: 672:86 error: method `emit_uint` is not a member of trait `serialize::Encoder`
src/bencode.rs:672     fn emit_uint(&mut self, v: uint) -> EncoderResult<()> { self.emit_i64(v as i64) }
                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/bencode.rs:682:5: 682:84 error: method `emit_int` is not a member of trait `serialize::Encoder`
src/bencode.rs:682     fn emit_int(&mut self, v: int) -> EncoderResult<()> { self.emit_i64(v as i64) }
                       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/bencode.rs:988:5: 991:6 error: method `read_uint` is not a member of trait `serialize::Decoder`
src/bencode.rs:988     fn read_uint(&mut self) -> DecoderResult<uint> {
src/bencode.rs:989         dec_expect_value!(self);
src/bencode.rs:990         self.try_read("uint")
src/bencode.rs:991     }
src/bencode.rs:1013:5: 1016:6 error: method `read_int` is not a member of trait `serialize::Decoder`
src/bencode.rs:1013     fn read_int(&mut self) -> DecoderResult<int> {
src/bencode.rs:1014         dec_expect_value!(self);
src/bencode.rs:1015         self.try_read("int")
src/bencode.rs:1016     }
error: aborting due to 4 previous errors
Could not compile `bencode`.

Would be appreciated if you could figure that out :)

Tuple structs are now allowed to have private fields which means you can not manually construct a Key with the old syntax.

This is annoying because scrape responses use the info-hash as dictionary keys.

Sorry I opened this just to ask a question... It seems to be the only place to do it.

Does your library support decoding when some elements might or might not be present? I think this is very important, specially when decoding .torrent files, because there are many optional fields according to the BitTorrent Protocol.

Another question is: does the library support getting the binary representation of a dictionary? This is needed in order to compute the sha1 hash of the info dictionary contained in .torrent files.

I get 77 errors when compiling (with cargo build as well as with make). They look like this:

src\bencode.rs:935:1: 939:3 note: in expansion of dec_expect_value!
src\bencode.rs:1189:9: 1189:29 note: expansion site
src\bencode.rs:936:8: 936:12 error: `self` is not available in a static method.
Maybe a `self` argument is missing?
src\bencode.rs:936     if self.expect_key {
                          ^~~~
src\bencode.rs:935:1: 939:3 note: in expansion of dec_expect_value!
src\bencode.rs:1197:9: 1197:29 note: expansion site

However, the Travis build passes... How is that possible? I am using the latest rustc nightly.

I have recreated the issue in a small code snippet on the playpen: http://is.gd/EAiKNk

This fixes two classes of compilation errors:

• use of FromStrRadix, which was removed from std::num recently
• use of is/us suffixes, which were changed to isize and usize

to_str_hex was also deprecated and removed. The deprecation note says to use format!. I assume this refers to the {:x} format specifier, but the trait isn't implemented for floats, which is what to_str_hex was being used for. I'm not sure what to do here, so I left it alone in this PR.

This changes the implementation of Show for util::ByteString and Bencode::ByteString so that when they contain valid utf8 they are shown as strings. ie. s"foo" instead of s[102, 111, 111].

'lib' in Cargo.toml is expected to be an array [[lib]], not table [lib](thanks for Toml developer for 'obvious' format).

Both variants pass locally but for mysterious reasons table one fails on Travis.

Successful build: https://travis-ci.org/Divius/rust-bencode

Hi,

PR #38 introduced a fix for current Rust versions. Could you make a new release and publish it to crates.io so we can use it without pointing to git?

Thanks!

Using rust 0.10, "make" was failing with this output:

mkdir -p build
mkdir -p build/test
rustc --test -o build/test/test src/bencode.rs
src/streaming.rs:34:16: 34:31 error: private type in exported type signature, #[deny(visible_private_types)] on by default
src/streaming.rs:34     stack: Vec<BencodePosition>,
                                   ^~~~~~~~~~~~~~~
error: aborting due to previous error
make: *** [libtest] Error 101

The way I was thinking of implementing this is to create a BencodeSlice<'a> type that serves a similar role to Bencode except that it keeps the encoded data as a slice into the buffer from which it was parsed. Something like this:

pub struct BencodeSlice<'a> {
    encoded: &'a [u8],
    decoded: BencodeSliceEntry<'a>,
}

pub enum BencodeSliceEntry<'a> {
    Empty,
    Number(i64),
    ByteString(&'a [u8]),
    List(Vec<BencodeSlice<'a>>),
    Dict(TreeMap<&'a [u8], BencodeSlice<'a>>),
}

You could then have a FromBencodeSlice trait that takes a BencodeSlice instead of a Bencode and I could use the encoded field of the BencodeSlice to calculate the sha1 info-hash of a torrent.

This would also have the advantage of making it slightly more efficient to parse and process bencoded data because it would eliminate the need to allocate unnecessarily for strings and dictionary keys.

The disadvantage of this is it would require rewriting the meat of the library so that the parser processes a &[u8] instead of an Iterator<u8>. In other words, replacing the streaming and BencodeEvent stuff with a different implementation. The only other library I can find on github that uses this library doesn't use the BencodeEvent stuff so I don't whether this would be an issue or not.

Would you (@aranjtop) accept a pull request that makes such sweeping changes to this library? Or should I just write another bencode library? I'd rather not write another library as this library is already pretty good and I don't like there being multiple rust library for doing the same thing.

There are 2 things in this library called ByteString: enum item ByteString and type util::ByteString used as a key. Placing in util:: mod looks like it's something auxiliary while actually it's necessary part of the core functionality (I can hardly imagine implementing To/FromBencode without using it explicitly). I am working around this like:

use bencode;
use bencode::util::ByteString;
...

Now I have ByteString and bencode::ByteString, both from bencode package. Guess which one is which :) Judging by use case, the could should be Key (why you didn't use it as initally wanted?) or smth like BytesHelper.

Could you rename one of ByteString's and move the second one to the top level of your package?

In a .torrent file, the hashes of the pieces are saved as a string. However, this string does not match Rust's String type, because it contains incorrect UTF8. What we actually want is to save the hashes in a Vec<u8>, but then the library will try to parse a list and produce an error.

Is there a work-around for this?