TRF_PROTOBUF

Defines

TRF_MSG__APIVERSION__INIT

TRF_MSG__LIBRARY_VERSION__INIT

TRF_MSG__ADDR_CAND__INIT

TRF_MSG__TRANSPORT__INIT

TRF_MSG__DISPLAY__INIT

TRF_MSG__CLIENT_HELLO__INIT

TRF_MSG__SERVER_HELLO__INIT

TRF_MSG__SERVER_REJECT__INIT

TRF_MSG__ADDR_PF__INIT

TRF_MSG__CLIENT_CAP__INIT

TRF_MSG__SERVER_CAP__INIT

TRF_MSG__TRANSPORT_NACK__INIT

TRF_MSG__ENDPOINT__INIT

TRF_MSG__CLIENT_DISP_REQ__INIT

TRF_MSG__SERVER_DISP__INIT

TRF_MSG__CLIENT_REQ__INIT

TRF_MSG__SERVER_ACK_REQ__INIT

TRF_MSG__DISPLAY_REQ__INIT

TRF_MSG__CLIENT_FREQ__INIT

TRF_MSG__SERVER_NOTIFY_CHUNK__INIT

TRF_MSG__SERVER_ACK_FREQ__INIT

TRF_MSG__DISCONNECT__INIT

TRF_MSG__CHANNEL_OPEN__INIT

TRF_MSG__CHANNEL_HELLO__INIT

TRF_MSG__KEEP_ALIVE__INIT

TRF_MSG__MESSAGE_WRAPPER__INIT

Typedefs

typedefPROTOBUF_C__BEGIN_DECLS struct TrfMsg__APIVersion TrfMsg__APIVersion

typedef struct TrfMsg__LibraryVersion TrfMsg__LibraryVersion

typedef struct TrfMsg__AddrCand TrfMsg__AddrCand

typedef struct TrfMsg__Transport TrfMsg__Transport

typedef struct TrfMsg__Display TrfMsg__Display

typedef struct TrfMsg__ClientHello TrfMsg__ClientHello

typedef struct TrfMsg__ServerHello TrfMsg__ServerHello

typedef struct TrfMsg__ServerReject TrfMsg__ServerReject

typedef struct TrfMsg__AddrPF TrfMsg__AddrPF

typedef struct TrfMsg__ClientCap TrfMsg__ClientCap

typedef struct TrfMsg__ServerCap TrfMsg__ServerCap

typedef struct TrfMsg__TransportNack TrfMsg__TransportNack

typedef struct TrfMsg__Endpoint TrfMsg__Endpoint

typedef struct TrfMsg__ClientDispReq TrfMsg__ClientDispReq

typedef struct TrfMsg__ServerDisp TrfMsg__ServerDisp

typedef struct TrfMsg__ClientReq TrfMsg__ClientReq

typedef struct TrfMsg__ServerAckReq TrfMsg__ServerAckReq

typedef struct TrfMsg__DisplayReq TrfMsg__DisplayReq

typedef struct TrfMsg__ClientFReq TrfMsg__ClientFReq

typedef struct TrfMsg__ServerNotifyChunk TrfMsg__ServerNotifyChunk

typedef struct TrfMsg__ServerAckFReq TrfMsg__ServerAckFReq

typedef struct TrfMsg__Disconnect TrfMsg__Disconnect

typedef struct TrfMsg__ChannelOpen TrfMsg__ChannelOpen

typedef struct TrfMsg__ChannelHello TrfMsg__ChannelHello

typedef struct TrfMsg__KeepAlive TrfMsg__KeepAlive

typedef struct TrfMsg__MessageWrapper TrfMsg__MessageWrapper

typedef void (*TrfMsg__APIVersion_Closure)(const TrfMsg__APIVersion *message, void *closure_data)

typedef void (*TrfMsg__LibraryVersion_Closure)(const TrfMsg__LibraryVersion *message, void *closure_data)

typedef void (*TrfMsg__AddrCand_Closure)(const TrfMsg__AddrCand *message, void *closure_data)

typedef void (*TrfMsg__Transport_Closure)(const TrfMsg__Transport *message, void *closure_data)

typedef void (*TrfMsg__Display_Closure)(const TrfMsg__Display *message, void *closure_data)

typedef void (*TrfMsg__ClientHello_Closure)(const TrfMsg__ClientHello *message, void *closure_data)

typedef void (*TrfMsg__ServerHello_Closure)(const TrfMsg__ServerHello *message, void *closure_data)

typedef void (*TrfMsg__ServerReject_Closure)(const TrfMsg__ServerReject *message, void *closure_data)

typedef void (*TrfMsg__AddrPF_Closure)(const TrfMsg__AddrPF *message, void *closure_data)

typedef void (*TrfMsg__ClientCap_Closure)(const TrfMsg__ClientCap *message, void *closure_data)

typedef void (*TrfMsg__ServerCap_Closure)(const TrfMsg__ServerCap *message, void *closure_data)

typedef void (*TrfMsg__TransportNack_Closure)(const TrfMsg__TransportNack *message, void *closure_data)

typedef void (*TrfMsg__Endpoint_Closure)(const TrfMsg__Endpoint *message, void *closure_data)

typedef void (*TrfMsg__ClientDispReq_Closure)(const TrfMsg__ClientDispReq *message, void *closure_data)

typedef void (*TrfMsg__ServerDisp_Closure)(const TrfMsg__ServerDisp *message, void *closure_data)

typedef void (*TrfMsg__ClientReq_Closure)(const TrfMsg__ClientReq *message, void *closure_data)

typedef void (*TrfMsg__ServerAckReq_Closure)(const TrfMsg__ServerAckReq *message, void *closure_data)

typedef void (*TrfMsg__DisplayReq_Closure)(const TrfMsg__DisplayReq *message, void *closure_data)

typedef void (*TrfMsg__ClientFReq_Closure)(const TrfMsg__ClientFReq *message, void *closure_data)

typedef void (*TrfMsg__ServerNotifyChunk_Closure)(const TrfMsg__ServerNotifyChunk *message, void *closure_data)

typedef void (*TrfMsg__ServerAckFReq_Closure)(const TrfMsg__ServerAckFReq *message, void *closure_data)

typedef void (*TrfMsg__Disconnect_Closure)(const TrfMsg__Disconnect *message, void *closure_data)

typedef void (*TrfMsg__ChannelOpen_Closure)(const TrfMsg__ChannelOpen *message, void *closure_data)

typedef void (*TrfMsg__ChannelHello_Closure)(const TrfMsg__ChannelHello *message, void *closure_data)

typedef void (*TrfMsg__KeepAlive_Closure)(const TrfMsg__KeepAlive *message, void *closure_data)

typedef void (*TrfMsg__MessageWrapper_Closure)(const TrfMsg__MessageWrapper *message, void *closure_data)

Enums

enum TrfMsg__MessageWrapper__WdataCase

Values:

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA__NOT_SET

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CLIENT_HELLO

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_HELLO

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_REJECT

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_DISCONNECT

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CLIENT_F_REQ

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_N_CHUNK

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_ACK_F_REQ

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CLIENT_CAP

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_CAP

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_TRANSPORT_NACK

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_ENDPOINT

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CLIENT_DISP_REQ

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_DISP

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CLIENT_REQ

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_SERVER_ACK

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_ADDR_PF

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CH_OPEN

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_CH_HELLO

enumerator TRF_MSG__MESSAGE_WRAPPER__WDATA_KA

Functions

void trf_msg__apiversion__init(TrfMsg__APIVersion *message)

size_t trf_msg__apiversion__get_packed_size(const TrfMsg__APIVersion *message)

size_t trf_msg__apiversion__pack(const TrfMsg__APIVersion *message, uint8_t *out)

size_t trf_msg__apiversion__pack_to_buffer(const TrfMsg__APIVersion *message, ProtobufCBuffer *buffer)

TrfMsg__APIVersion *trf_msg__apiversion__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__apiversion__free_unpacked(TrfMsg__APIVersion *message, ProtobufCAllocator *allocator)

void trf_msg__library_version__init(TrfMsg__LibraryVersion *message)

size_t trf_msg__library_version__get_packed_size(const TrfMsg__LibraryVersion *message)

size_t trf_msg__library_version__pack(const TrfMsg__LibraryVersion *message, uint8_t *out)

size_t trf_msg__library_version__pack_to_buffer(const TrfMsg__LibraryVersion *message, ProtobufCBuffer *buffer)

TrfMsg__LibraryVersion *trf_msg__library_version__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__library_version__free_unpacked(TrfMsg__LibraryVersion *message, ProtobufCAllocator *allocator)

void trf_msg__addr_cand__init(TrfMsg__AddrCand *message)

size_t trf_msg__addr_cand__get_packed_size(const TrfMsg__AddrCand *message)

size_t trf_msg__addr_cand__pack(const TrfMsg__AddrCand *message, uint8_t *out)

size_t trf_msg__addr_cand__pack_to_buffer(const TrfMsg__AddrCand *message, ProtobufCBuffer *buffer)

TrfMsg__AddrCand *trf_msg__addr_cand__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__addr_cand__free_unpacked(TrfMsg__AddrCand *message, ProtobufCAllocator *allocator)

void trf_msg__transport__init(TrfMsg__Transport *message)

size_t trf_msg__transport__get_packed_size(const TrfMsg__Transport *message)

size_t trf_msg__transport__pack(const TrfMsg__Transport *message, uint8_t *out)

size_t trf_msg__transport__pack_to_buffer(const TrfMsg__Transport *message, ProtobufCBuffer *buffer)

TrfMsg__Transport *trf_msg__transport__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__transport__free_unpacked(TrfMsg__Transport *message, ProtobufCAllocator *allocator)

void trf_msg__display__init(TrfMsg__Display *message)

size_t trf_msg__display__get_packed_size(const TrfMsg__Display *message)

size_t trf_msg__display__pack(const TrfMsg__Display *message, uint8_t *out)

size_t trf_msg__display__pack_to_buffer(const TrfMsg__Display *message, ProtobufCBuffer *buffer)

TrfMsg__Display *trf_msg__display__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__display__free_unpacked(TrfMsg__Display *message, ProtobufCAllocator *allocator)

void trf_msg__client_hello__init(TrfMsg__ClientHello *message)

size_t trf_msg__client_hello__get_packed_size(const TrfMsg__ClientHello *message)

size_t trf_msg__client_hello__pack(const TrfMsg__ClientHello *message, uint8_t *out)

size_t trf_msg__client_hello__pack_to_buffer(const TrfMsg__ClientHello *message, ProtobufCBuffer *buffer)

TrfMsg__ClientHello *trf_msg__client_hello__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__client_hello__free_unpacked(TrfMsg__ClientHello *message, ProtobufCAllocator *allocator)

void trf_msg__server_hello__init(TrfMsg__ServerHello *message)

size_t trf_msg__server_hello__get_packed_size(const TrfMsg__ServerHello *message)

size_t trf_msg__server_hello__pack(const TrfMsg__ServerHello *message, uint8_t *out)

size_t trf_msg__server_hello__pack_to_buffer(const TrfMsg__ServerHello *message, ProtobufCBuffer *buffer)

TrfMsg__ServerHello *trf_msg__server_hello__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_hello__free_unpacked(TrfMsg__ServerHello *message, ProtobufCAllocator *allocator)

void trf_msg__server_reject__init(TrfMsg__ServerReject *message)

size_t trf_msg__server_reject__get_packed_size(const TrfMsg__ServerReject *message)

size_t trf_msg__server_reject__pack(const TrfMsg__ServerReject *message, uint8_t *out)

size_t trf_msg__server_reject__pack_to_buffer(const TrfMsg__ServerReject *message, ProtobufCBuffer *buffer)

TrfMsg__ServerReject *trf_msg__server_reject__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_reject__free_unpacked(TrfMsg__ServerReject *message, ProtobufCAllocator *allocator)

void trf_msg__addr_pf__init(TrfMsg__AddrPF *message)

size_t trf_msg__addr_pf__get_packed_size(const TrfMsg__AddrPF *message)

size_t trf_msg__addr_pf__pack(const TrfMsg__AddrPF *message, uint8_t *out)

size_t trf_msg__addr_pf__pack_to_buffer(const TrfMsg__AddrPF *message, ProtobufCBuffer *buffer)

TrfMsg__AddrPF *trf_msg__addr_pf__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__addr_pf__free_unpacked(TrfMsg__AddrPF *message, ProtobufCAllocator *allocator)

void trf_msg__client_cap__init(TrfMsg__ClientCap *message)

size_t trf_msg__client_cap__get_packed_size(const TrfMsg__ClientCap *message)

size_t trf_msg__client_cap__pack(const TrfMsg__ClientCap *message, uint8_t *out)

size_t trf_msg__client_cap__pack_to_buffer(const TrfMsg__ClientCap *message, ProtobufCBuffer *buffer)

TrfMsg__ClientCap *trf_msg__client_cap__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__client_cap__free_unpacked(TrfMsg__ClientCap *message, ProtobufCAllocator *allocator)

void trf_msg__server_cap__init(TrfMsg__ServerCap *message)

size_t trf_msg__server_cap__get_packed_size(const TrfMsg__ServerCap *message)

size_t trf_msg__server_cap__pack(const TrfMsg__ServerCap *message, uint8_t *out)

size_t trf_msg__server_cap__pack_to_buffer(const TrfMsg__ServerCap *message, ProtobufCBuffer *buffer)

TrfMsg__ServerCap *trf_msg__server_cap__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_cap__free_unpacked(TrfMsg__ServerCap *message, ProtobufCAllocator *allocator)

void trf_msg__transport_nack__init(TrfMsg__TransportNack *message)

size_t trf_msg__transport_nack__get_packed_size(const TrfMsg__TransportNack *message)

size_t trf_msg__transport_nack__pack(const TrfMsg__TransportNack *message, uint8_t *out)

size_t trf_msg__transport_nack__pack_to_buffer(const TrfMsg__TransportNack *message, ProtobufCBuffer *buffer)

TrfMsg__TransportNack *trf_msg__transport_nack__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__transport_nack__free_unpacked(TrfMsg__TransportNack *message, ProtobufCAllocator *allocator)

void trf_msg__endpoint__init(TrfMsg__Endpoint *message)

size_t trf_msg__endpoint__get_packed_size(const TrfMsg__Endpoint *message)

size_t trf_msg__endpoint__pack(const TrfMsg__Endpoint *message, uint8_t *out)

size_t trf_msg__endpoint__pack_to_buffer(const TrfMsg__Endpoint *message, ProtobufCBuffer *buffer)

TrfMsg__Endpoint *trf_msg__endpoint__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__endpoint__free_unpacked(TrfMsg__Endpoint *message, ProtobufCAllocator *allocator)

void trf_msg__client_disp_req__init(TrfMsg__ClientDispReq *message)

size_t trf_msg__client_disp_req__get_packed_size(const TrfMsg__ClientDispReq *message)

size_t trf_msg__client_disp_req__pack(const TrfMsg__ClientDispReq *message, uint8_t *out)

size_t trf_msg__client_disp_req__pack_to_buffer(const TrfMsg__ClientDispReq *message, ProtobufCBuffer *buffer)

TrfMsg__ClientDispReq *trf_msg__client_disp_req__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__client_disp_req__free_unpacked(TrfMsg__ClientDispReq *message, ProtobufCAllocator *allocator)

void trf_msg__server_disp__init(TrfMsg__ServerDisp *message)

size_t trf_msg__server_disp__get_packed_size(const TrfMsg__ServerDisp *message)

size_t trf_msg__server_disp__pack(const TrfMsg__ServerDisp *message, uint8_t *out)

size_t trf_msg__server_disp__pack_to_buffer(const TrfMsg__ServerDisp *message, ProtobufCBuffer *buffer)

TrfMsg__ServerDisp *trf_msg__server_disp__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_disp__free_unpacked(TrfMsg__ServerDisp *message, ProtobufCAllocator *allocator)

void trf_msg__client_req__init(TrfMsg__ClientReq *message)

size_t trf_msg__client_req__get_packed_size(const TrfMsg__ClientReq *message)

size_t trf_msg__client_req__pack(const TrfMsg__ClientReq *message, uint8_t *out)

size_t trf_msg__client_req__pack_to_buffer(const TrfMsg__ClientReq *message, ProtobufCBuffer *buffer)

TrfMsg__ClientReq *trf_msg__client_req__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__client_req__free_unpacked(TrfMsg__ClientReq *message, ProtobufCAllocator *allocator)

void trf_msg__server_ack_req__init(TrfMsg__ServerAckReq *message)

size_t trf_msg__server_ack_req__get_packed_size(const TrfMsg__ServerAckReq *message)

size_t trf_msg__server_ack_req__pack(const TrfMsg__ServerAckReq *message, uint8_t *out)

size_t trf_msg__server_ack_req__pack_to_buffer(const TrfMsg__ServerAckReq *message, ProtobufCBuffer *buffer)

TrfMsg__ServerAckReq *trf_msg__server_ack_req__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_ack_req__free_unpacked(TrfMsg__ServerAckReq *message, ProtobufCAllocator *allocator)

void trf_msg__display_req__init(TrfMsg__DisplayReq *message)

size_t trf_msg__display_req__get_packed_size(const TrfMsg__DisplayReq *message)

size_t trf_msg__display_req__pack(const TrfMsg__DisplayReq *message, uint8_t *out)

size_t trf_msg__display_req__pack_to_buffer(const TrfMsg__DisplayReq *message, ProtobufCBuffer *buffer)

TrfMsg__DisplayReq *trf_msg__display_req__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__display_req__free_unpacked(TrfMsg__DisplayReq *message, ProtobufCAllocator *allocator)

void trf_msg__client_freq__init(TrfMsg__ClientFReq *message)

size_t trf_msg__client_freq__get_packed_size(const TrfMsg__ClientFReq *message)

size_t trf_msg__client_freq__pack(const TrfMsg__ClientFReq *message, uint8_t *out)

size_t trf_msg__client_freq__pack_to_buffer(const TrfMsg__ClientFReq *message, ProtobufCBuffer *buffer)

TrfMsg__ClientFReq *trf_msg__client_freq__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__client_freq__free_unpacked(TrfMsg__ClientFReq *message, ProtobufCAllocator *allocator)

void trf_msg__server_notify_chunk__init(TrfMsg__ServerNotifyChunk *message)

size_t trf_msg__server_notify_chunk__get_packed_size(const TrfMsg__ServerNotifyChunk *message)

size_t trf_msg__server_notify_chunk__pack(const TrfMsg__ServerNotifyChunk *message, uint8_t *out)

size_t trf_msg__server_notify_chunk__pack_to_buffer(const TrfMsg__ServerNotifyChunk *message, ProtobufCBuffer *buffer)

TrfMsg__ServerNotifyChunk *trf_msg__server_notify_chunk__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_notify_chunk__free_unpacked(TrfMsg__ServerNotifyChunk *message, ProtobufCAllocator *allocator)

void trf_msg__server_ack_freq__init(TrfMsg__ServerAckFReq *message)

size_t trf_msg__server_ack_freq__get_packed_size(const TrfMsg__ServerAckFReq *message)

size_t trf_msg__server_ack_freq__pack(const TrfMsg__ServerAckFReq *message, uint8_t *out)

size_t trf_msg__server_ack_freq__pack_to_buffer(const TrfMsg__ServerAckFReq *message, ProtobufCBuffer *buffer)

TrfMsg__ServerAckFReq *trf_msg__server_ack_freq__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__server_ack_freq__free_unpacked(TrfMsg__ServerAckFReq *message, ProtobufCAllocator *allocator)

void trf_msg__disconnect__init(TrfMsg__Disconnect *message)

size_t trf_msg__disconnect__get_packed_size(const TrfMsg__Disconnect *message)

size_t trf_msg__disconnect__pack(const TrfMsg__Disconnect *message, uint8_t *out)

size_t trf_msg__disconnect__pack_to_buffer(const TrfMsg__Disconnect *message, ProtobufCBuffer *buffer)

TrfMsg__Disconnect *trf_msg__disconnect__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__disconnect__free_unpacked(TrfMsg__Disconnect *message, ProtobufCAllocator *allocator)

void trf_msg__channel_open__init(TrfMsg__ChannelOpen *message)

size_t trf_msg__channel_open__get_packed_size(const TrfMsg__ChannelOpen *message)

size_t trf_msg__channel_open__pack(const TrfMsg__ChannelOpen *message, uint8_t *out)

size_t trf_msg__channel_open__pack_to_buffer(const TrfMsg__ChannelOpen *message, ProtobufCBuffer *buffer)

TrfMsg__ChannelOpen *trf_msg__channel_open__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__channel_open__free_unpacked(TrfMsg__ChannelOpen *message, ProtobufCAllocator *allocator)

void trf_msg__channel_hello__init(TrfMsg__ChannelHello *message)

size_t trf_msg__channel_hello__get_packed_size(const TrfMsg__ChannelHello *message)

size_t trf_msg__channel_hello__pack(const TrfMsg__ChannelHello *message, uint8_t *out)

size_t trf_msg__channel_hello__pack_to_buffer(const TrfMsg__ChannelHello *message, ProtobufCBuffer *buffer)

TrfMsg__ChannelHello *trf_msg__channel_hello__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__channel_hello__free_unpacked(TrfMsg__ChannelHello *message, ProtobufCAllocator *allocator)

void trf_msg__keep_alive__init(TrfMsg__KeepAlive *message)

size_t trf_msg__keep_alive__get_packed_size(const TrfMsg__KeepAlive *message)

size_t trf_msg__keep_alive__pack(const TrfMsg__KeepAlive *message, uint8_t *out)

size_t trf_msg__keep_alive__pack_to_buffer(const TrfMsg__KeepAlive *message, ProtobufCBuffer *buffer)

TrfMsg__KeepAlive *trf_msg__keep_alive__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__keep_alive__free_unpacked(TrfMsg__KeepAlive *message, ProtobufCAllocator *allocator)

void trf_msg__message_wrapper__init(TrfMsg__MessageWrapper *message)

size_t trf_msg__message_wrapper__get_packed_size(const TrfMsg__MessageWrapper *message)

size_t trf_msg__message_wrapper__pack(const TrfMsg__MessageWrapper *message, uint8_t *out)

size_t trf_msg__message_wrapper__pack_to_buffer(const TrfMsg__MessageWrapper *message, ProtobufCBuffer *buffer)

TrfMsg__MessageWrapper *trf_msg__message_wrapper__unpack(ProtobufCAllocator *allocator, size_t len, const uint8_t *data)

void trf_msg__message_wrapper__free_unpacked(TrfMsg__MessageWrapper *message, ProtobufCAllocator *allocator)

Variables

const ProtobufCMessageDescriptor trf_msg__apiversion__descriptor

const ProtobufCMessageDescriptor trf_msg__library_version__descriptor

const ProtobufCMessageDescriptor trf_msg__addr_cand__descriptor

const ProtobufCMessageDescriptor trf_msg__transport__descriptor

const ProtobufCMessageDescriptor trf_msg__display__descriptor

const ProtobufCMessageDescriptor trf_msg__client_hello__descriptor

const ProtobufCMessageDescriptor trf_msg__server_hello__descriptor

const ProtobufCMessageDescriptor trf_msg__server_reject__descriptor

const ProtobufCMessageDescriptor trf_msg__addr_pf__descriptor

const ProtobufCMessageDescriptor trf_msg__client_cap__descriptor

const ProtobufCMessageDescriptor trf_msg__server_cap__descriptor

const ProtobufCMessageDescriptor trf_msg__transport_nack__descriptor

const ProtobufCMessageDescriptor trf_msg__endpoint__descriptor

const ProtobufCMessageDescriptor trf_msg__client_disp_req__descriptor

const ProtobufCMessageDescriptor trf_msg__server_disp__descriptor

const ProtobufCMessageDescriptor trf_msg__client_req__descriptor

const ProtobufCMessageDescriptor trf_msg__server_ack_req__descriptor

const ProtobufCMessageDescriptor trf_msg__display_req__descriptor

const ProtobufCMessageDescriptor trf_msg__client_freq__descriptor

const ProtobufCMessageDescriptor trf_msg__server_notify_chunk__descriptor

const ProtobufCMessageDescriptor trf_msg__server_ack_freq__descriptor

const ProtobufCMessageDescriptor trf_msg__disconnect__descriptor

const ProtobufCMessageDescriptor trf_msg__channel_open__descriptor

const ProtobufCMessageDescriptor trf_msg__channel_hello__descriptor

const ProtobufCMessageDescriptor trf_msg__keep_alive__descriptor

const ProtobufCMessageDescriptor trf_msg__message_wrapper__descriptor

struct TrfMsg__APIVersion

#include <trf_msg.pb-c.h>

API version message The initial message exchanged between server and client should be the API versions. In the test versions, the API is not considered stable; any differences in API version from server to client, including patch versions, should be considered unstable.

Public Members

ProtobufCMessage base

uint32_t api_major

Major release version

uint32_t api_minor

Minor release version

uint32_t api_patch

Patch version

size_t n_lv

Versions of installed transport libraries.

TrfMsg__LibraryVersion **lv

struct TrfMsg__LibraryVersion

#include <trf_msg.pb-c.h>

Library version message A message containing the library name as well as the version integer and minimum compatible version. A samplle version number is constructed as follows: Major version: ((uint16_t) MY_LIBRARY_VERSION_MAJOR) << 48 Minor version: ((uint16_t) MY_LIBRARY_VERSION_MINOR) << 32 Patch version: ((uint16_t) MY_LIBRARY_VERSION_PATCH) << 16 Library specific: ((uint16_t) MY_LIBRARY_SPECIFIC_NUM) The only official library supported by LibTRF is Libfabric, with a library ID number of 1. Custom transport libraries should use an ID number between 1024-2047.

Public Members

ProtobufCMessage base

uint32_t lib

Library identifier

uint64_t version

Library version

uint64_t compat

Minimum compatible version

struct TrfMsg__AddrCand

#include <trf_msg.pb-c.h>

Connection address candidates Clients and servers exchange addressing information in order to determine fabrics which can reach the link. Note that currently there is no support for routing outside of a broadcast domain, although many fabric types such as RoCEv1 do not support this feature as well.

Public Members

ProtobufCMessage base

char *addr

Interface address

int32_t netmask

Netmask

int32_t port

Preflight check port

int32_t speed

Link speed

struct TrfMsg__Transport

#include <trf_msg.pb-c.h>

Transport candidates Transport candidates contain data obtained from the fabric provider, serialized for transmission over the network. Currently, there is only support for Libfabric and some of the transports which it contains, with testing performed on the verbs;ofi_rxm and tcp;ofi_rxm transports only.

Public Members

ProtobufCMessage base

char *name

Transport provider name e.g. “tcp;ofi_rxm”

char *proto

Transport wire protocol e.g. “FI_PROTO_RXM”

char *src

Transport provider source address. May be NULL if addressing is assigned dynamically.

char *dest

Destination information as returned by the AddrCand messages

struct TrfMsg__Display

#include <trf_msg.pb-c.h>

Display/Viewport information A display message is sent by the source in response to a display request, indicating which displays are available to the source, as well as extra metadata such as the texture formats and display group IDs.

Public Members

ProtobufCMessage base

uint32_t id

Display ID A display identifier uniquely identifies the monitor within a TRF context. It is an opaque value, without any intrinsic meaning and as such may be assigned randomly. Independent server contexts may reuse the display identifiers.

char *name

Display friendly name This name should be presented to API and end users. It is recommended that functions which set this value be predictable so as to allow for automated setup. For instance, it may be set to the display name.

uint32_t width

Width in pixels.

uint32_t height

Height in pixels.

int32_t rate

Refresh rate The refresh rate is used to determine frame pacing when clients request frame data updates be sent to them. If this value is not set, frame requests always begin processing immediately without being deferred to the next vblank, which may result in repeated frames and excessive bandwidth utilization.

size_t n_tex_fmt

Natively supported texture formats The actual definition of texture formats are stored externally. This field may be repeated, in case multiple texture formats are natively supported. Currently, LibTRF supports only one texture format, and the API will select the first item in the list should this field be repeated.

uint32_t *tex_fmt

uint32_t dgid

Display Group ID (DGID) Display groups are designed to allow servers to multiplex display sources without the need to run multiple discrete instances of LibTRF. For instance, a single LibTRF server running on a VM host could act as the framebuffer source for multiple virtual machines. Displays within a group can be positioned in a group coordinate space, allowing the client to determine positioning for a multi-monitor setup.

int32_t x_offset

The relative X position of the monitor.

int32_t y_offset

The relative Y position of the monitor.

struct TrfMsg__ClientHello

#include <trf_msg.pb-c.h>

Client hello This must be the first message sent over the negotiation channel. It should contain the client’s LibTRF version.

Public Members

ProtobufCMessage base

TrfMsg__APIVersion *version

API version

struct TrfMsg__ServerHello

#include <trf_msg.pb-c.h>

Server hello Should the client hello API version match the version supported by the server, this message should be sent.

Public Members

ProtobufCMessage base

uint64_t new_session_id

New session ID

struct TrfMsg__ServerReject

#include <trf_msg.pb-c.h>

Server rejection Currently, the only reason for a server rejection is that the API version has mismatched between the client and server. More reasons, such as server overload are planned.

Public Members

ProtobufCMessage base

TrfMsg__APIVersion *version

Server API version This should contain the server API version to be sent to the client, in order to inform the user which API version is required to allow for successful communication with the server.

struct TrfMsg__AddrPF

#include <trf_msg.pb-c.h>

Address preflight candidates Currently unused.

Public Members

ProtobufCMessage base

size_t n_addrs

Address candidates

TrfMsg__AddrCand **addrs

struct TrfMsg__ClientCap

#include <trf_msg.pb-c.h>

Client capabilities A ClientCap message contains the available fabric transports supported by the client. Currently, this information is sourced entirely from the Libfabric API.

Public Members

ProtobufCMessage base

size_t n_transports

The list of transports supported by the client.

TrfMsg__Transport **transports

struct TrfMsg__ServerCap

#include <trf_msg.pb-c.h>

Server capabilities The server should examine a ClientCap message, sending back the best transport common between both the client and server. For instance, Verbs transports should be preferred over non-accelerated TCP transports, determined on the server side.

Public Members

ProtobufCMessage base

char *bind_addr

The recommended client bind address. This may optionally be used by the client to bind to a specific interface suggested by the server to be the most likely to be functional.

TrfMsg__Transport *transport

Transport to use, selected by the server.

struct TrfMsg__TransportNack

#include <trf_msg.pb-c.h>

Transport NACK Either the server or client may send a TransportNack message to indicate that either the client’s transport list is incompatible with the server’s capabilities, or that the client is unable to connect to the server’s transport candidate.

Public Members

ProtobufCMessage base

uint32_t index

Transport index.

uint32_t reason

NACK reason.

struct TrfMsg__Endpoint

#include <trf_msg.pb-c.h>

Created endpoint name Once a client has created an endpoint, the details should be sent to the server in order to determine the address the server should listen for.

Public Members

ProtobufCMessage base

TrfMsg__Transport *transport

Transport containing details of the endpoint which was just created by the client.

struct TrfMsg__ClientDispReq

#include <trf_msg.pb-c.h>

Client display list request The client should send this data to determine the list of displays on the server side.

Public Members

ProtobufCMessage base

uint32_t info

Unused

struct TrfMsg__ServerDisp

#include <trf_msg.pb-c.h>

Server display list This should be sent in response to a ClientDispReq message, containing the displays available for the client to use.

Public Members

ProtobufCMessage base

size_t n_displays

List of displays on server side

TrfMsg__Display **displays

struct TrfMsg__ClientReq

#include <trf_msg.pb-c.h>

Client request A client request contains the list of displays the client wishes the server enable. See the DisplayReq message for more details.

Public Members

ProtobufCMessage base

size_t n_display

Requested displays from server

TrfMsg__DisplayReq **display

struct TrfMsg__ServerAckReq

#include <trf_msg.pb-c.h>

Server request acknowledgement A server request acknowledgement contains a list of displays IDs that were requested by the client as well as the status of the request.

Public Members

ProtobufCMessage base

size_t n_display_ids

Display ID list.

uint32_t *display_ids

size_t n_return_codes

Display ID status. For instance, display_ids[0] has a corresponding return code of return_codes[0]. The return codes’ meanings must be in line with the POSIX.1-2008 standard. Most of the common POSIX error codes are also available on Windows, inside errno.h.

uint32_t *return_codes

struct TrfMsg__DisplayReq

#include <trf_msg.pb-c.h>

Display initialization request This message requests the server initialize the capture source with the specified parameters. This indicates that resources should be set up and memory be allocated in preparation for frame requests.

Public Members

ProtobufCMessage base

uint32_t id

Requested display ID.

uint32_t width

Requested display width The width may differ from the display’s native width if downscaling is preferred. However, LibTRF does not support downscaling functionality, and as such the implementation is up to the user’s application.

uint32_t height

Requested display height The height may differ from the display’s native height if downscaling is preferred. However, LibTRF does not support downscaling functionality, and as such the implementation is up to the user’s application.

uint32_t tex_fmt

Requested texture format The texture format must be within the supported texture format list sent in the initial display list message. An API for texture format transcoding support is planned, but currently unsupported.

struct TrfMsg__ClientFReq

#include <trf_msg.pb-c.h>

Client frame update request This message should be sent as soon as the client has received a frame, processed it, with the supplied buffer ready to receive new data. Behaviour on the server side may be controlled with the flags argument.

Public Members

ProtobufCMessage base

uint32_t id

Display ID to update.

uint32_t frame_cntr

The current frame number counter.

uint64_t addr

Client receive address in virtual memory. This address may not be a memory region offset.

uint64_t rkey

Client receive rkey. The remote access key for the client.

ProtobufCBinaryData raw_key

Client receive raw key. Currently unsupported. Fabrics with key sizes that exceed 64-bits may use this field. The raw_rkey field takes precedence over the rkey field, so should be set to a NULL value if unused.

uint64_t flags

Flags used to control the operation. For instance, a client may request the server return data immediately, ignoring any imposed vertical sync delays, or retransmit the current frame.

struct TrfMsg__ServerNotifyChunk

#include <trf_msg.pb-c.h>

DMA completion notification for a data chunk

While a ServerAckFReq message should be sent once a frame is ready, this may introduce additional latency on the receiver side due to the fact that the read and write operations occur sequentially. To allow for some degree of parallelization, the server may send notifications when chunks of data have been sent. Note that the processing of such notifications can be rather expensive on both ends, and as such a reasonable chunk size should be selected in accordance with the available network bandwidth as well as the total frame size.

Public Members

ProtobufCMessage base

uint32_t id

The display ID that was updated.

uint32_t frame_cntr

The region that was updated.

uint32_t mode

Mode indicator. Currently, the following modes are defined: 0: The notification contains a raw offset from the start of the frame buffer in bytes, as well as its length. 1: The notification contains the coordinates and size of a rectangle, describing the region that was updated.

uint64_t offset

Raw update chunk offset.

uint64_t offset_len

Length of the data past the offset that was updated.

uint32_t rect_x

Rectangle X position.

uint32_t rect_y

Rectangle Y position.

uint32_t rect_width

Rectangle width.

uint32_t rect_height

Rectangle height.

struct TrfMsg__ServerAckFReq

#include <trf_msg.pb-c.h>

Frame request acknowledgement

The server should send a frame request acknowledgement after the frame has been sent and the buffer is safe to read from. In most fabric providers, such as Verbs, RMA read/write operations do not return a confirmation on the target side, and if these operations do in fact return data, this should not be relied on. Instead, clients should wait for this message as a confirmation that the buffer is ready.

Public Members

ProtobufCMessage base

uint32_t id

The display ID that was updated.

uint32_t frame_cntr

The identifier for the newly updated frame.

struct TrfMsg__Disconnect

#include <trf_msg.pb-c.h>

Disconnect message The server or client may send a disconnect message. The receiver should then treat the connection as closed and release the resources associated with the sender. Determining the client is done through the use of the session_id value inside of the parent message wrapper.

Public Members

ProtobufCMessage base

uint32_t info

Extra info e.g. error, unused

struct TrfMsg__ChannelOpen

#include <trf_msg.pb-c.h>

Subchannel open.

Public Members

ProtobufCMessage base

uint32_t id

Channel ID

TrfMsg__Transport *transport

Transport details

protobuf_c_boolean reply

Indicates the message is a reply to a previous ChannelOpen message.

struct TrfMsg__ChannelHello

#include <trf_msg.pb-c.h>

Hello message.

Public Members

ProtobufCMessage base

uint32_t channel_id

Channel identifier

protobuf_c_boolean reply

Reply flag

struct TrfMsg__KeepAlive

#include <trf_msg.pb-c.h>

Keep alive message Keeps the connection alive to avoid timeouts. This is used, for example, if either side would like to keep the connection open if they are either paused or waiting for new frame data.

Public Members

ProtobufCMessage base

uint32_t info

Info (currently unused)

struct TrfMsg__MessageWrapper

#include <trf_msg.pb-c.h>

Message wrapper All TRF messages are contained within a message wrapper, identifying the client using the session_id, with one message payload contained within wdata.

Public Members

ProtobufCMessage base

uint64_t session_id

Session identifier.

TrfMsg__MessageWrapper__WdataCase wdata_case

TrfMsg__ClientHello *client_hello

TrfMsg__ServerHello *server_hello

TrfMsg__ServerReject *server_reject

TrfMsg__Disconnect *disconnect

TrfMsg__ClientFReq *client_f_req

TrfMsg__ServerNotifyChunk *server_n_chunk

TrfMsg__ServerAckFReq *server_ack_f_req

TrfMsg__ClientCap *client_cap

TrfMsg__ServerCap *server_cap

TrfMsg__TransportNack *transport_nack

TrfMsg__Endpoint *endpoint

TrfMsg__ClientDispReq *client_disp_req

TrfMsg__ServerDisp *server_disp

TrfMsg__ClientReq *client_req

TrfMsg__ServerAckReq *server_ack

TrfMsg__AddrPF *addr_pf

TrfMsg__ChannelOpen *ch_open

TrfMsg__ChannelHello *ch_hello

TrfMsg__KeepAlive *ka

union TrfMsg__MessageWrapper::[anonymous] [anonymous]