> This page is for version 3.0 (Latest) (default).
> For other versions, use one of these documentation indexes:
> - 3.0 (Latest) (default): https://docs.nvidia.com/holoscan/sensor-bridge/3-0/llms.txt
> - 2.7: https://docs.nvidia.com/holoscan/sensor-bridge/2-7/llms.txt
> - Archives: https://docs.nvidia.com/holoscan/sensor-bridge/archives/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/holoscan/sensor-bridge/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/holoscan/sensor-bridge/_mcp/server.

# hololink::module::LinuxDataChannelInterfaceV1

> Provide support for Linux data receivers.

Provide support for Linux data receivers.

For systems without hardware accelerated RDMA for delivery of received data, a Linux specific emulator for this is available, which uses the CPU to receive HSB data (via UDP) into a local buffer, and on the frame-end condition, that buffer is copied into the target (usually GPU) memory.

Application code would normally interact with a Linux receiver object, which uses this object to support configuration of the local data receiver socket.

```cpp showLineNumbers={false}
#include <hololink/module/linux_data_channel.hpp>
```

**Inherits from:** `hololink::module::ConfigurableService< LinuxDataChannelInterfaceV1 >` (public)

---

## Methods

### configure_socket \[#configuresocket]

```cpp showLineNumbers={false}
virtual hololink_module_status_t hololink::module::LinuxDataChannelInterfaceV1::configure_socket(
    int data_socket
)
```

Prepare a datagram socket to receive this channel's traffic.

Binds the socket to the host interface that reaches the device. When the channel's enumeration metadata selects multicast or broadcast delivery, the socket joins that group or accepts that broadcast; otherwise the host assigns it a port, and attach_receiver() programs the device to transmit there.

The application creates the socket and calls this before anything else runs on it.

**Returns:** HOLOLINK_MODULE_OK or an error status.

**Parameters**

**`data_socket`** `int`

Datagram socket to prepare.

---

### attach_receiver \[#attachreceiver]

```cpp showLineNumbers={false}
virtual hololink_module_status_t hololink::module::LinuxDataChannelInterfaceV1::attach_receiver(
    std::shared_ptr<LinuxReceiverInterfaceV1> receiver
)
```

Deliver this channel's frames to a running receiver.

Programs the device to transmit frames to the receiver; the frame layout it transmits – frame size, page size and page count – and the destination port come from the receiver, so the receiver is started, on a socket configure_socket() prepared, before this call. Frames arrive from here on. Pair it with detach_receiver() before tearing the channel down.

**Returns:** HOLOLINK_MODULE_OK or an error status.

**Parameters**

**`receiver`** `std::shared_ptr<LinuxReceiverInterfaceV1>`

The started receiver frames are delivered to.

---

### detach_receiver \[#detachreceiver]

```cpp showLineNumbers={false}
virtual hololink_module_status_t hololink::module::LinuxDataChannelInterfaceV1::detach_receiver()
```

Stop transmitting, clearing the state attach_receiver() set up.

The channel delivers nothing until another attach_receiver(). This writes to the device, so it fails when the device is unreachable.

**Returns:** HOLOLINK_MODULE_OK or an error status.

### frame_end_sequencer \[#frameendsequencer]

```cpp showLineNumbers={false}
template <typename T = SequencerInterfaceV1>
std::shared_ptr<T> hololink::module::LinuxDataChannelInterfaceV1::frame_end_sequencer(
    bool allow_null = false
)
```

The sequencer this channel triggers at the end of each frame.

The device runs the sequence once per completed frame on this channel. Receivers add the device reads they want taken with every frame.

**Returns:** The sequencer.

**Template parameters**

**`T`** `typename`

The interface version to fetch.

---

**Parameters**

**`allow_null`** `bool` — default: false

Return an empty pointer, rather than throwing, when this channel publishes no such sequencer.

---

### get_hololink \[#gethololink]

```cpp showLineNumbers={false}
template <typename T = HololinkInterfaceV1>
std::shared_ptr<T> hololink::module::LinuxDataChannelInterfaceV1::get_hololink(
    bool allow_null = false
)
```

The device this channel runs on.

The same device DataChannelInterfaceV1::hololink() returns for this channel, for callers holding the software transport.

**Returns:** The device.

**Template parameters**

**`T`** `typename`

The interface version to fetch.

---

**Parameters**

**`allow_null`** `bool` — default: false

Return an empty pointer, rather than throwing, when this device is not published.

---

### configure \[#configure]

```cpp showLineNumbers={false}
virtual void hololink::module::ConfigurableService<LinuxDataChannelInterfaceV1>::configure(
    const EnumerationMetadata &
)
```

Use `metadata` contents to initialize this instance.

This routine is guaranteed to be called the first time a call to get_service(metadata) is called on a specific service instance.

### module \[#module]

```cpp showLineNumbers={false}
std::shared_ptr<Module> hololink::module::ServiceBase::module() const
```

The [Module](module) that this service was published from.

The service holds no strong reference to its [Module](module), so this does not extend the [Module](module)'s lifetime.

**Returns:** The owning [Module](module), or an empty pointer if the service has not been published or its [Module](module) no longer exists.

---

## Static methods

### get_service \[#getservice]

#### Fetch a service

```cpp showLineNumbers={false}
static std::shared_ptr<LinuxDataChannelInterfaceV1> hololink::module::ConfigurableService<LinuxDataChannelInterfaceV1>::get_service(
    const EnumerationMetadata &metadata,
    bool allow_null = false
)
```

Fetch a service, configured by [EnumerationMetadata](enumerationmetadata).

[Module](module) usually caches service objects; so when a specific service instance isn't found, it will be constructed with the current values in [EnumerationMetadata](enumerationmetadata). Later calls to get_service are likely to return that cached instance, ignoring changes to any enumeration metadata that aren't specifically related to service addressing.

**Returns:** A shared pointer to the requested service (\<Derived>).

**Throws:** `std::runtime_error` when allow_null==false and the service lookup (or construction) fails.

**Parameters**

**`metadata`** `const EnumerationMetadata &`

Addressing and configuration for the service.

---

**`allow_null`** `bool` — default: false

Use `true` to return nullptr when the service cannot be resolved; the default `false` value raises a std::runtime_error.

---

#### Overload 2

inline

```cpp showLineNumbers={false}
static std::shared_ptr<LinuxDataChannelInterfaceV1> hololink::module::Service<LinuxDataChannelInterfaceV1>::get_service(
    std::shared_ptr<Module> module,
    const char *instance_id,
    bool allow_null = false
)
```

Type-safe way to fetch a std::shared_ptr to an instance of \<Derived> from a [Module](module).

Note that [Module](module) usually caches instances, it's likely that calls to get_service with the same locator_id will return pointers to the same implementation object.

**Returns:** A shared pointer to the service instance.

**Parameters**

**`module`** `std::shared_ptr<Module>`

Is the shared object that owns the instance we wish to fetch

---

**`instance_id`** `const char *`

Names the specific object, usually expressed as a set of "name=value;..." pairs, as defined by the implementations themselves. This name is normally fetched by calling `Derived::locator_id(enumeration_metadata)`.

---

**`allow_null`** `bool` — default: false

The default value of `false` causes this routine to throw a std::runtime_error if the service cannot be found within the module; this would be expected to terminate the calling program. If the application wants to handle the error, pass in `true` here and get_service will return `nullptr` when this module doesn't provide the requested service.

---

### for_each_type_id \[#foreachtypeid]

```cpp showLineNumbers={false}
static bool hololink::module::Service<LinuxDataChannelInterfaceV1>::for_each_type_id(
    Callback &&cb
)
```

Iterate over every type_id supported by this instance.

The callback signature is `bool(const char*)` — returning false halts the walk; true continues. Iteration is depth-first, so you'll see the most specific implementation types first.