someip-wire 0.1.1

A no_std SOME/IP wire protocol parser and serializer with zero-allocation design
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

# someip-wire

[![Crates.io](https://img.shields.io/crates/v/someip-wire.svg)](https://crates.io/crates/someip-wire)
[![Documentation](https://docs.rs/someip-wire/badge.svg)](https://docs.rs/someip-wire)
[![License](https://img.shields.io/crates/l/someip-wire.svg)](https://github.com/martinpalsson/someip-wire#license)

A `no_std` Rust crate for parsing and serializing SOME/IP (Scalable service-Oriented MiddlewarE over IP) wire protocol packets.

Based on the [AUTOSAR SOME/IP Protocol Specification](https://www.autosar.org/fileadmin/standards/R22-11/FO/AUTOSAR_PRS_SOMEIPProtocol.pdf).

## Scope

**This crate focuses solely on SOME/IP header parsing and serialization.**

The crate parses the standardized 16-byte SOME/IP header and provides the payload data as a raw byte slice. It does NOT parse the payload content itself, as payload format is entirely application-specific and defined by service interface definitions (e.g., FIDL/Franca IDL).

### Architecture

To build a complete SOME/IP stack using this crate:

1. **Use `someip-wire`** to parse/emit SOME/IP headers (this crate)
2. **Implement payload parsers** based on your service interface definitions
3. **Route messages** by connecting service/method IDs to their respective payload handlers

This separation of concerns keeps the crate focused, lightweight, and universally applicable across different SOME/IP service implementations and OEM-specific requirements.

## Features

- **`no_std` compatible** - Works in embedded environments
- **Zero-allocation** - All operations work on borrowed data
- **Type-safe API** - Clean enums for message types and return codes
- **Efficient wire format** - Direct u8 operations at the packet level
- **Two-layer architecture** - Low-level packet access + high-level representation

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
someip-wire = "0.1.0"
```

## Examples

### Parsing a SOME/IP packet

```rust
use someip_wire::packet::Packet;
use someip_wire::payload::Repr;

let buffer = [
    0x12, 0x34, 0x00, 0x01, // Message ID
    0x00, 0x00, 0x00, 0x08, // Length
    0x00, 0x01, 0x00, 0x00, // Request ID
    0x01,                   // Protocol version
    0x01,                   // Interface version
    0x00,                   // Message type (Request)
    0x00,                   // Return code (E_OK)
    // Payload data
    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
];

let packet = Packet::new_unchecked(&buffer);
let repr = Repr::parse(&packet).unwrap();

assert_eq!(repr.protocol_version, 0x01);
assert_eq!(repr.data.len(), 8);
// repr.data contains the raw payload bytes - parse based on your service definition
```

### Creating a SOME/IP packet

```rust
use someip_wire::packet::Packet;
use someip_wire::payload::Repr;
use someip_wire::types::{MessageId, RequestId, ClientId, MessageType, ReturnCode};

let repr = Repr {
    message_id: MessageId {
        service_id: 0x1234,
        method_id: 0x0001,
    },
    length: 8,
    request_id: RequestId {
        client_id: ClientId {
            client_id_prefix: 0x00,
            client_id: 0x01,
        },
        session_id: 0x0000,
    },
    protocol_version: 0x01,
    interface_version: 0x01,
    message_type: MessageType::Response,
    return_code: ReturnCode::E_OK,
    data: &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08], // Your serialized payload
};

let mut buffer = [0u8; 24];
let mut packet = Packet::new_unchecked(&mut buffer);
repr.emit(&mut packet);
```

**Note:** The `data` field contains your service-specific payload. You are responsible for serializing/deserializing this based on your service interface definitions.

### Working with return codes

```rust
use someip_wire::types::ReturnCode;

// Named return codes
let ok = ReturnCode::E_OK;
let timeout = ReturnCode::E_TIMEOUT;

// Reserved ranges
let someip_reserved = ReturnCode::ReservedSomeIP(0x15);
let service_reserved = ReturnCode::ReservedServiceMethod(0x30);

// Check properties
assert!(ok.is_ok());
assert!(someip_reserved.is_reserved_someip());
```

## Architecture

The crate uses a two-layer architecture:

- **Wire format layer** (`packet` module) - Works directly with raw bytes using u8 values for maximum efficiency
- **Representation layer** (`payload`, `types` modules) - Provides type-safe enums and structs for ergonomic API

This ensures zero-cost abstractions while maintaining a pleasant developer experience.

## License

Licensed under either of:

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.