Hey,

I'm currently working on a Macho parser and couldn't figure out how to declare sized char arrays (char foo[16]). I tried [u8; 16], with no luck.

Is that possible right now at all?

Thanks!

I am having issues with getting the feature to use Uuid to work.

Cargo.toml:

[dependencies]
protocol-derive = "3.1.3"
protocol= { version = "3.1.3", features = ["uuid"] }
uuid="0.8.1"

Trying to compile something simple as

use uuid::Uuid;
use protocol_derive::Protocol;

#[derive(Protocol, Debug, Copy, Clone, PartialEq, Eq)]
pub struct Foo {
    pub id: Uuid,
}

And then I got a compiler error:

#[derive(Protocol, Debug, Copy, Clone, PartialEq, Eq)]
|        ^^^^^^^^ the trait `id::__impl_protocol___Parcel_FOR_Foo::protocol::HighLevel` is not implemented for `uuid::Uuid`

Am I missing something?

I am interested in retrieving the discriminant of the packet that I have received. Though it seams as this is not possible. And I only wish to ask if I have understood this correctly?

If we use the example from the documentation. What would hope would be possible would be to do the following:

    loop {
        if let Some(response) = connection.receive_packet().unwrap() {
            println!("{:?}", response.discriminant());
            break;
        }
    }

But to me it seams as the only way one can retrieve discriminators is through the enum that defines the protocol?

#[macro_use] extern crate protocol_derive;
#[macro_use] extern crate protocol;

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Handshake;

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Hello {
    id: i64,
    data: Vec<u8>,
}

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Goodbye {
    id: i64,
    reason: String,
}

#[protocol(discriminant = "integer")]
#[derive(Protocol, Clone, Debug, PartialEq)]
#[repr(u16)]
pub enum PacketKind {
    #[protocol(discriminator(0x00))]
    Handshake(Handshake),
    #[protocol(discriminator(0xaa))]
    Hello(Hello),
    #[protocol(discriminator(0xaf))]
    Goodbye(Goodbye),
}

fn main() {
println!("Disc: {}", Packet::Handshake(Handshake)).discriminant());
}

In order to get the discriminant of message do I have to write my own function that checks the message type and return the appropriate discriminator by constructing a temporary object and extract it from the temporary object?

use protocol_derive;
use protocol::{ByteOrder, Enum, Parcel, Settings};

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Handshake;

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Hello {
    id: i64,
    data: Vec<u8>,
}

#[derive(Protocol, Clone, Debug, PartialEq)]
pub struct Goodbye {
    id: i64,
    reason: String,
}

#[protocol(discriminant = "integer")]
#[derive(Protocol, Clone, Debug, PartialEq)]
#[repr(u16)]
pub enum PacketKind {
    #[protocol(discriminator(0x00))]
    Handshake(Handshake),
    #[protocol(discriminator(0xaa))]
    Hello(Hello),
    #[protocol(discriminator(0xaf))]
    Goodbye(Goodbye),
}

impl PacketKind {
pub fn get_discriminator(&self) -> u16 {
match self {
    PacketKind::Handshake(_) => {
        PacketKind::Handshake(Handshake).discriminator()
    },
    PacketKind::Hello(_) => {
       PacketKind::Hello(Hello {id: Default::default(), data: Default::default() }).discriminant()
    },
    PacketKind::GoodBye(_) => {
        PacketKind::Goodbye(GoodBye {id: Default::default(), reason: "".to_string() }).discriminant()
    },
}

It seam really weird that the library user would have to go through all this trouble to get the discriminant of the received package or am I missing something?

error[E0271]: type mismatch resolving `<i64 as std::convert::TryFrom<i8>>::Error == std::num::TryFromIntError`
   --> ...\protocol-0.3.1\src\primitives\numerics.rs:102:6
    |
102 | impl Integer for i64 { }
    |      ^^^^^^^ expected enum `std::convert::Infallible`, found struct `std::num::TryFromIntError`
    |
    = note: expected type `std::convert::Infallible`
               found type `std::num::TryFromIntError`

This panic line caused one of our production systems to crash when trying to decode messages on a noisy channel.

https://github.com/dylanmckay/protocol/blob/ae808cf8f6b723c1edf38e0d4d731b9240eb76f5/protocol-derive/src/codegen/enums.rs#L66

Now, I'm happy to fix this and submit a pull request but how? Because this is part of the derived parcel implementation, I'm not sure what the generated code ends up looking like or what can be returned here to replace the panic

I am currently implementing a protocol that has 17 bytes or things that I don't care for now and then a 0 terminated string. It is datagram based, so the length of the packet is very clear from the start.

I am not the creator of the protocol, it has been around for 20 years or so.

Is there any way I can decode that string? What happens if there are bytes left to consume?

Removed TryFrom in favor of num-traits

• Allows protocol to work in stable rust
• Fixes the compiler errors in the latest nightly (caused by https://github.com/rust-lang/rust/pull/44174)

Currently, there is the distinction between a Type that can be serialised, and a Packet that can be serialised. They both share almost the exact same definition.

It would be good to merge the two traits into one. This would allow connections to be build using primitives as packets, and also make everything more consistent.

Currently

#[derive(Protocol)]
enum Event<E: Event> {
   // ...
}

will work.

However

#[derive(Protocol)]
enum Event<E> where E: Event {
   // ...
}

does not. protocol-derive only looks at the constraints on the generic types, it currently fails to look at the where clause constraints and add them to the new impl Parcel.

Something like this needs to be done

diff --git a/protocol-derive/src/lib.rs b/protocol-derive/src/lib.rs
index 517c224..dfeda42 100644
--- a/protocol-derive/src/lib.rs
+++ b/protocol-derive/src/lib.rs
@@ -37,7 +37,7 @@ fn impl_parcel(ast: &syn::DeriveInput) -> proc_macro2::TokenStream {
 /// Returns `(generics, where_predicates)`
 fn build_generics(ast: &syn::DeriveInput) -> (Vec<proc_macro2::TokenStream>, Vec<proc_macro2::TokenStream>) {
     let mut where_predicates = Vec::new();
-    let generics: Vec<_> = ast.generics.params.iter().enumerate().map(|(i, p)| {
+    let generics: Vec<_> = ast.generics.type_params().enumerate().map(|(i, p)| {
         match p {
             syn::GenericParam::Type(t) => {
                 let (ident, bounds) = (&t.ident, &t.bounds);

NOTE: this if 1/3rd of a proper fix. A proper fix would also check generics.lifetimes() and generics.const_params and copy the constraints to the new impl. Currently the patch would ignore lifetime parameters and break all traits with lifetime type parameters.

Hello , is it possible to set a fixed length for a string field ? I would need something like this :

#[derive(Protocol, Debug, Clone, PartialEq, Eq)]
pub struct DatFile {
    #[protocol(fixed_lenght(8))]
    game_version: String,
}

The protocol I am implementing has certain quirks. It is a opcode u16 based protocol, so first 2 bytes define the rest, but:

Some packets can be embebbed into other packets and depending on that, a CRC is added at the end or not.

Does protocol has a easy way to map this? Is there a way that I can provide custom settings or hints ?

I have tried to use this with a non_blocking socket and I get some weird error:

panicked at 'called `Result::unwrap()` on an `Err` value: Os { code: 11, kind: WouldBlock, message: "Resource temporarily unavailable" }'
protocol-3.1.3/src/wire/stream/transport/simple.rs:116:30

Is non blocking sockets supported?

Returns a Result<Option<P>, Error>, but the docs are a bit terse

https://docs.rs/protocol/3.1.4/protocol/wire/stream/struct.Connection.html#method.receive_packet

Attempts to receive a packet

• Is this a non-blocking call?
• What does Ok(None) mean here? Is it an error? If this is non-blocking, does it mean try again later?