/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: unpriv_access.proto */

#ifndef PROTOBUF_C_unpriv_5faccess_2eproto__INCLUDED
#define PROTOBUF_C_unpriv_5faccess_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protobuf-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1005002 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protobuf-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protobuf-c.
#endif


typedef struct StatusRequest StatusRequest;
typedef struct StatusResponse StatusResponse;
typedef struct JentStatusRequest JentStatusRequest;
typedef struct JentStatusResponse JentStatusResponse;
typedef struct GetEntLvlRequest GetEntLvlRequest;
typedef struct GetEntLvlResponse GetEntLvlResponse;
typedef struct IsFullySeededRequest IsFullySeededRequest;
typedef struct IsFullySeededResponse IsFullySeededResponse;
typedef struct GetRandomBytesFullRequest GetRandomBytesFullRequest;
typedef struct GetRandomBytesFullResponse GetRandomBytesFullResponse;
typedef struct GetRandomBytesPrRequest GetRandomBytesPrRequest;
typedef struct GetRandomBytesPrResponse GetRandomBytesPrResponse;
typedef struct GetSeedRequest GetSeedRequest;
typedef struct GetSeedResponse GetSeedResponse;
typedef struct GetRandomBytesRequest GetRandomBytesRequest;
typedef struct GetRandomBytesResponse GetRandomBytesResponse;
typedef struct WriteDataRequest WriteDataRequest;
typedef struct WriteDataResponse WriteDataResponse;
typedef struct RndGetEntCntRequest RndGetEntCntRequest;
typedef struct RndGetEntCntResponse RndGetEntCntResponse;
typedef struct GetPoolsizeRequest GetPoolsizeRequest;
typedef struct GetPoolsizeResponse GetPoolsizeResponse;
typedef struct GetWriteWakeupThreshRequest GetWriteWakeupThreshRequest;
typedef struct GetWriteWakeupThreshResponse GetWriteWakeupThreshResponse;
typedef struct GetMinReseedSecsRequest GetMinReseedSecsRequest;
typedef struct GetMinReseedSecsResponse GetMinReseedSecsResponse;


/* --- enums --- */


/* --- messages --- */

/*
 **
 * @brief Request to get status
 * @param maxlen Maximum size of buffer
 */
struct  StatusRequest
{
  ProtobufCMessage base;
  uint32_t maxlen;
};
#define STATUS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&status_request__descriptor) \
, 0 }


/*
 **
 * @brief Response to get status
 * @param buffer_len Number of bytes present in the buffer - if no message
 *		     buffer is returned, this value specifies the number of
 *		     required bytes.
 * @param buffer Buffer with ASCII status - this is a NULL-terminated string
 */
struct  StatusResponse
{
  ProtobufCMessage base;
  int32_t ret;
  char *buffer;
};
#define STATUS_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&status_response__descriptor) \
, 0, (char *)protobuf_c_empty_string }


/*
 **
 * @brief Request to get Jitterentropy status
 * @param maxlen Maximum size of buffer
 */
struct  JentStatusRequest
{
  ProtobufCMessage base;
  uint32_t maxlen;
};
#define JENT_STATUS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&jent_status_request__descriptor) \
, 0 }


/*
 **
 * @brief Response to get status
 * @param buffer_len Number of bytes present in the buffer - if no message
 *		     buffer is returned, this value specifies the number of
 *		     required bytes.
 * @param buffer Buffer with ASCII status - this is a NULL-terminated string
 */
struct  JentStatusResponse
{
  ProtobufCMessage base;
  int32_t ret;
  char *buffer;
};
#define JENT_STATUS_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&jent_status_response__descriptor) \
, 0, (char *)protobuf_c_empty_string }


/*
 **
 * @brief Request to obtain the overall available entropy level
 */
struct  GetEntLvlRequest
{
  ProtobufCMessage base;
};
#define GET_ENT_LVL_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_ent_lvl_request__descriptor) \
 }


/*
 **
 * @brief Response returning the overall available entropy level
 * @param ret Return code (0 on success, < 0 on error)
 * @param entcnt Available entropy in bits
 */
struct  GetEntLvlResponse
{
  ProtobufCMessage base;
  int32_t ret;
  uint32_t entlvl;
};
#define GET_ENT_LVL_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_ent_lvl_response__descriptor) \
, 0, 0 }


/*
 **
 * @brief Request to get fully seeded status
 */
struct  IsFullySeededRequest
{
  ProtobufCMessage base;
};
#define IS_FULLY_SEEDED_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&is_fully_seeded_request__descriptor) \
 }


/*
 **
 * @brief Response to get fully seeded status
 * @param ret Return code (0 on success, < 0 on error)
 * @param fully_seeded fully seeded status (true if fully seeded,
 *					   false otherwise)
 */
struct  IsFullySeededResponse
{
  ProtobufCMessage base;
  int32_t ret;
  protobuf_c_boolean fully_seeded;
};
#define IS_FULLY_SEEDED_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&is_fully_seeded_response__descriptor) \
, 0, 0 }


/*
 **
 * @brief Request to get random bytes from fully seeded DRNG
 * @param len number of random bytes that are requested
 */
struct  GetRandomBytesFullRequest
{
  ProtobufCMessage base;
  uint64_t len;
};
#define GET_RANDOM_BYTES_FULL_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_full_request__descriptor) \
, 0 }


/*
 **
 * @brief Response providing random bytes from fully seeded DRNG
 * @param ret Return code of generation request (> 0 on success with the value
 *	      indicating the generated number of random bytes,
 *	      < -255 indicating the maximum number of bytes that can be
 *	      transferred in one request, < 0 on error)
 * @param randval Random bytes
 */
struct  GetRandomBytesFullResponse
{
  ProtobufCMessage base;
  int64_t ret;
  ProtobufCBinaryData randval;
};
#define GET_RANDOM_BYTES_FULL_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_full_response__descriptor) \
, 0, {0,NULL} }


/*
 **
 * @brief Request to get random bytes from fully seeded DRNG with prediction
 *	  resistance enabled
 * @param len number of random bytes that are requested
 */
struct  GetRandomBytesPrRequest
{
  ProtobufCMessage base;
  uint64_t len;
};
#define GET_RANDOM_BYTES_PR_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_pr_request__descriptor) \
, 0 }


/*
 **
 * @brief Response providing random bytes from fully seeded DRNG with prediction
 *	  resistance enabled.
 * @param ret Return code of generation request (>= 0 on success with the value
 *	      indicating the generated number of random bytes,
 *	      < -255 indicating the maximum number of bytes that can be
 *	      transferred in one request, < 0 on error)
 * @param randval Random bytes
 */
struct  GetRandomBytesPrResponse
{
  ProtobufCMessage base;
  int64_t ret;
  ProtobufCBinaryData randval;
};
#define GET_RANDOM_BYTES_PR_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_pr_response__descriptor) \
, 0, {0,NULL} }


/*
 **
 * @brief Request to get seed from entropy sources
 * @param len buffer size provided by caller
 * @param flags the flags field - see esdm_get_seed documentation
 */
struct  GetSeedRequest
{
  ProtobufCMessage base;
  uint64_t len;
  uint32_t flags;
};
#define GET_SEED_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_seed_request__descriptor) \
, 0, 0 }


/*
 **
 * @brief Response providing seed data from entropy sources.
 * @param ret Return code of generation request as documented for esdm_get_seed
 * @param randval seed data
 */
struct  GetSeedResponse
{
  ProtobufCMessage base;
  int64_t ret;
  ProtobufCBinaryData randval;
};
#define GET_SEED_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_seed_response__descriptor) \
, 0, {0,NULL} }


/*
 **
 * @brief Request to get random bytes from DRNG that has no guarantee of being
 *	  initialized at the time random numbers are generated.
 * @param len number of random bytes that are requested
 */
struct  GetRandomBytesRequest
{
  ProtobufCMessage base;
  uint64_t len;
};
#define GET_RANDOM_BYTES_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_request__descriptor) \
, 0 }


/*
 **
 * @brief Response providing random bytes from DRNG that has no guarantee of
 *	  being initialized at the time random numbers are generated.
 * @param ret Return code of generation request (> 0 on success with the value
 *	      indicating the generated number of random bytes,
 *	      < -255 indicating the maximum number of bytes that can be
 *	      transferred in one request, < 0 on error)
 * @param randval Random bytes
 */
struct  GetRandomBytesResponse
{
  ProtobufCMessage base;
  int64_t ret;
  ProtobufCBinaryData randval;
};
#define GET_RANDOM_BYTES_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_random_bytes_response__descriptor) \
, 0, {0,NULL} }


/*
 **
 * @brief Request to write data into the auxiliary entropy pool and perform an
 *	  immediate reseed.
 * @param data Buffer with the data to write into the DRNG - the entropy
 *	       estimator will remain unchanged.
 */
struct  WriteDataRequest
{
  ProtobufCMessage base;
  ProtobufCBinaryData data;
};
#define WRITE_DATA_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&write_data_request__descriptor) \
, {0,NULL} }


/*
 **
 * @brief Response providing the result of the write operation
 * @param ret Return code (0 on success, < 0 on error)
 */
struct  WriteDataResponse
{
  ProtobufCMessage base;
  int32_t ret;
};
#define WRITE_DATA_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&write_data_response__descriptor) \
, 0 }


/*
 **
 * @brief Request to obtain the available entropy in auxiliary pool
 */
struct  RndGetEntCntRequest
{
  ProtobufCMessage base;
};
#define RND_GET_ENT_CNT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rnd_get_ent_cnt_request__descriptor) \
 }


/*
 **
 * @brief Response returning the available entropy in auxiliary pool
 * @param ret Return code (0 on success, < 0 on error)
 * @param entcnt Available entropy in bits
 */
struct  RndGetEntCntResponse
{
  ProtobufCMessage base;
  int32_t ret;
  uint32_t entcnt;
};
#define RND_GET_ENT_CNT_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rnd_get_ent_cnt_response__descriptor) \
, 0, 0 }


/*
 **
 * @brief Request to obtain the available poolsize
 */
struct  GetPoolsizeRequest
{
  ProtobufCMessage base;
};
#define GET_POOLSIZE_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_poolsize_request__descriptor) \
 }


/*
 **
 * @brief Response returning the available poolsize
 * @param ret Return code (0 on success, < 0 on error)
 * @param poolsize Available poolsize in bits
 */
struct  GetPoolsizeResponse
{
  ProtobufCMessage base;
  int32_t ret;
  uint32_t poolsize;
};
#define GET_POOLSIZE_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_poolsize_response__descriptor) \
, 0, 0 }


/*
 **
 * @brief Request to obtain the available write wakeup threshold
 */
struct  GetWriteWakeupThreshRequest
{
  ProtobufCMessage base;
};
#define GET_WRITE_WAKEUP_THRESH_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_write_wakeup_thresh_request__descriptor) \
 }


/*
 **
 * @brief Response returning the available write wakeup threshold
 * @param ret Return code (0 on success, < 0 on error)
 * @param wakeup Available write wakeup threshold in bits
 */
struct  GetWriteWakeupThreshResponse
{
  ProtobufCMessage base;
  int32_t ret;
  uint32_t wakeup;
};
#define GET_WRITE_WAKEUP_THRESH_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_write_wakeup_thresh_response__descriptor) \
, 0, 0 }


/*
 **
 * @brief Request to obtain the available write wakeup threshold
 */
struct  GetMinReseedSecsRequest
{
  ProtobufCMessage base;
};
#define GET_MIN_RESEED_SECS_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_min_reseed_secs_request__descriptor) \
 }


/*
 **
 * @brief Response returning the min reseed secs
 * @param ret Return code (0 on success, < 0 on error)
 * @param seconds Read time in seconds
 */
struct  GetMinReseedSecsResponse
{
  ProtobufCMessage base;
  int32_t ret;
  uint32_t seconds;
};
#define GET_MIN_RESEED_SECS_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&get_min_reseed_secs_response__descriptor) \
, 0, 0 }


/* StatusRequest methods */
void   status_request__init
                     (StatusRequest         *message);
size_t status_request__get_packed_size
                     (const StatusRequest   *message);
size_t status_request__pack
                     (const StatusRequest   *message,
                      uint8_t             *out);
size_t status_request__pack_to_buffer
                     (const StatusRequest   *message,
                      ProtobufCBuffer     *buffer);
StatusRequest *
       status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   status_request__free_unpacked
                     (StatusRequest *message,
                      ProtobufCAllocator *allocator);
/* StatusResponse methods */
void   status_response__init
                     (StatusResponse         *message);
size_t status_response__get_packed_size
                     (const StatusResponse   *message);
size_t status_response__pack
                     (const StatusResponse   *message,
                      uint8_t             *out);
size_t status_response__pack_to_buffer
                     (const StatusResponse   *message,
                      ProtobufCBuffer     *buffer);
StatusResponse *
       status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   status_response__free_unpacked
                     (StatusResponse *message,
                      ProtobufCAllocator *allocator);
/* JentStatusRequest methods */
void   jent_status_request__init
                     (JentStatusRequest         *message);
size_t jent_status_request__get_packed_size
                     (const JentStatusRequest   *message);
size_t jent_status_request__pack
                     (const JentStatusRequest   *message,
                      uint8_t             *out);
size_t jent_status_request__pack_to_buffer
                     (const JentStatusRequest   *message,
                      ProtobufCBuffer     *buffer);
JentStatusRequest *
       jent_status_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   jent_status_request__free_unpacked
                     (JentStatusRequest *message,
                      ProtobufCAllocator *allocator);
/* JentStatusResponse methods */
void   jent_status_response__init
                     (JentStatusResponse         *message);
size_t jent_status_response__get_packed_size
                     (const JentStatusResponse   *message);
size_t jent_status_response__pack
                     (const JentStatusResponse   *message,
                      uint8_t             *out);
size_t jent_status_response__pack_to_buffer
                     (const JentStatusResponse   *message,
                      ProtobufCBuffer     *buffer);
JentStatusResponse *
       jent_status_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   jent_status_response__free_unpacked
                     (JentStatusResponse *message,
                      ProtobufCAllocator *allocator);
/* GetEntLvlRequest methods */
void   get_ent_lvl_request__init
                     (GetEntLvlRequest         *message);
size_t get_ent_lvl_request__get_packed_size
                     (const GetEntLvlRequest   *message);
size_t get_ent_lvl_request__pack
                     (const GetEntLvlRequest   *message,
                      uint8_t             *out);
size_t get_ent_lvl_request__pack_to_buffer
                     (const GetEntLvlRequest   *message,
                      ProtobufCBuffer     *buffer);
GetEntLvlRequest *
       get_ent_lvl_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_ent_lvl_request__free_unpacked
                     (GetEntLvlRequest *message,
                      ProtobufCAllocator *allocator);
/* GetEntLvlResponse methods */
void   get_ent_lvl_response__init
                     (GetEntLvlResponse         *message);
size_t get_ent_lvl_response__get_packed_size
                     (const GetEntLvlResponse   *message);
size_t get_ent_lvl_response__pack
                     (const GetEntLvlResponse   *message,
                      uint8_t             *out);
size_t get_ent_lvl_response__pack_to_buffer
                     (const GetEntLvlResponse   *message,
                      ProtobufCBuffer     *buffer);
GetEntLvlResponse *
       get_ent_lvl_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_ent_lvl_response__free_unpacked
                     (GetEntLvlResponse *message,
                      ProtobufCAllocator *allocator);
/* IsFullySeededRequest methods */
void   is_fully_seeded_request__init
                     (IsFullySeededRequest         *message);
size_t is_fully_seeded_request__get_packed_size
                     (const IsFullySeededRequest   *message);
size_t is_fully_seeded_request__pack
                     (const IsFullySeededRequest   *message,
                      uint8_t             *out);
size_t is_fully_seeded_request__pack_to_buffer
                     (const IsFullySeededRequest   *message,
                      ProtobufCBuffer     *buffer);
IsFullySeededRequest *
       is_fully_seeded_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   is_fully_seeded_request__free_unpacked
                     (IsFullySeededRequest *message,
                      ProtobufCAllocator *allocator);
/* IsFullySeededResponse methods */
void   is_fully_seeded_response__init
                     (IsFullySeededResponse         *message);
size_t is_fully_seeded_response__get_packed_size
                     (const IsFullySeededResponse   *message);
size_t is_fully_seeded_response__pack
                     (const IsFullySeededResponse   *message,
                      uint8_t             *out);
size_t is_fully_seeded_response__pack_to_buffer
                     (const IsFullySeededResponse   *message,
                      ProtobufCBuffer     *buffer);
IsFullySeededResponse *
       is_fully_seeded_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   is_fully_seeded_response__free_unpacked
                     (IsFullySeededResponse *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesFullRequest methods */
void   get_random_bytes_full_request__init
                     (GetRandomBytesFullRequest         *message);
size_t get_random_bytes_full_request__get_packed_size
                     (const GetRandomBytesFullRequest   *message);
size_t get_random_bytes_full_request__pack
                     (const GetRandomBytesFullRequest   *message,
                      uint8_t             *out);
size_t get_random_bytes_full_request__pack_to_buffer
                     (const GetRandomBytesFullRequest   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesFullRequest *
       get_random_bytes_full_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_full_request__free_unpacked
                     (GetRandomBytesFullRequest *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesFullResponse methods */
void   get_random_bytes_full_response__init
                     (GetRandomBytesFullResponse         *message);
size_t get_random_bytes_full_response__get_packed_size
                     (const GetRandomBytesFullResponse   *message);
size_t get_random_bytes_full_response__pack
                     (const GetRandomBytesFullResponse   *message,
                      uint8_t             *out);
size_t get_random_bytes_full_response__pack_to_buffer
                     (const GetRandomBytesFullResponse   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesFullResponse *
       get_random_bytes_full_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_full_response__free_unpacked
                     (GetRandomBytesFullResponse *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesPrRequest methods */
void   get_random_bytes_pr_request__init
                     (GetRandomBytesPrRequest         *message);
size_t get_random_bytes_pr_request__get_packed_size
                     (const GetRandomBytesPrRequest   *message);
size_t get_random_bytes_pr_request__pack
                     (const GetRandomBytesPrRequest   *message,
                      uint8_t             *out);
size_t get_random_bytes_pr_request__pack_to_buffer
                     (const GetRandomBytesPrRequest   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesPrRequest *
       get_random_bytes_pr_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_pr_request__free_unpacked
                     (GetRandomBytesPrRequest *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesPrResponse methods */
void   get_random_bytes_pr_response__init
                     (GetRandomBytesPrResponse         *message);
size_t get_random_bytes_pr_response__get_packed_size
                     (const GetRandomBytesPrResponse   *message);
size_t get_random_bytes_pr_response__pack
                     (const GetRandomBytesPrResponse   *message,
                      uint8_t             *out);
size_t get_random_bytes_pr_response__pack_to_buffer
                     (const GetRandomBytesPrResponse   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesPrResponse *
       get_random_bytes_pr_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_pr_response__free_unpacked
                     (GetRandomBytesPrResponse *message,
                      ProtobufCAllocator *allocator);
/* GetSeedRequest methods */
void   get_seed_request__init
                     (GetSeedRequest         *message);
size_t get_seed_request__get_packed_size
                     (const GetSeedRequest   *message);
size_t get_seed_request__pack
                     (const GetSeedRequest   *message,
                      uint8_t             *out);
size_t get_seed_request__pack_to_buffer
                     (const GetSeedRequest   *message,
                      ProtobufCBuffer     *buffer);
GetSeedRequest *
       get_seed_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_seed_request__free_unpacked
                     (GetSeedRequest *message,
                      ProtobufCAllocator *allocator);
/* GetSeedResponse methods */
void   get_seed_response__init
                     (GetSeedResponse         *message);
size_t get_seed_response__get_packed_size
                     (const GetSeedResponse   *message);
size_t get_seed_response__pack
                     (const GetSeedResponse   *message,
                      uint8_t             *out);
size_t get_seed_response__pack_to_buffer
                     (const GetSeedResponse   *message,
                      ProtobufCBuffer     *buffer);
GetSeedResponse *
       get_seed_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_seed_response__free_unpacked
                     (GetSeedResponse *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesRequest methods */
void   get_random_bytes_request__init
                     (GetRandomBytesRequest         *message);
size_t get_random_bytes_request__get_packed_size
                     (const GetRandomBytesRequest   *message);
size_t get_random_bytes_request__pack
                     (const GetRandomBytesRequest   *message,
                      uint8_t             *out);
size_t get_random_bytes_request__pack_to_buffer
                     (const GetRandomBytesRequest   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesRequest *
       get_random_bytes_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_request__free_unpacked
                     (GetRandomBytesRequest *message,
                      ProtobufCAllocator *allocator);
/* GetRandomBytesResponse methods */
void   get_random_bytes_response__init
                     (GetRandomBytesResponse         *message);
size_t get_random_bytes_response__get_packed_size
                     (const GetRandomBytesResponse   *message);
size_t get_random_bytes_response__pack
                     (const GetRandomBytesResponse   *message,
                      uint8_t             *out);
size_t get_random_bytes_response__pack_to_buffer
                     (const GetRandomBytesResponse   *message,
                      ProtobufCBuffer     *buffer);
GetRandomBytesResponse *
       get_random_bytes_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_random_bytes_response__free_unpacked
                     (GetRandomBytesResponse *message,
                      ProtobufCAllocator *allocator);
/* WriteDataRequest methods */
void   write_data_request__init
                     (WriteDataRequest         *message);
size_t write_data_request__get_packed_size
                     (const WriteDataRequest   *message);
size_t write_data_request__pack
                     (const WriteDataRequest   *message,
                      uint8_t             *out);
size_t write_data_request__pack_to_buffer
                     (const WriteDataRequest   *message,
                      ProtobufCBuffer     *buffer);
WriteDataRequest *
       write_data_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   write_data_request__free_unpacked
                     (WriteDataRequest *message,
                      ProtobufCAllocator *allocator);
/* WriteDataResponse methods */
void   write_data_response__init
                     (WriteDataResponse         *message);
size_t write_data_response__get_packed_size
                     (const WriteDataResponse   *message);
size_t write_data_response__pack
                     (const WriteDataResponse   *message,
                      uint8_t             *out);
size_t write_data_response__pack_to_buffer
                     (const WriteDataResponse   *message,
                      ProtobufCBuffer     *buffer);
WriteDataResponse *
       write_data_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   write_data_response__free_unpacked
                     (WriteDataResponse *message,
                      ProtobufCAllocator *allocator);
/* RndGetEntCntRequest methods */
void   rnd_get_ent_cnt_request__init
                     (RndGetEntCntRequest         *message);
size_t rnd_get_ent_cnt_request__get_packed_size
                     (const RndGetEntCntRequest   *message);
size_t rnd_get_ent_cnt_request__pack
                     (const RndGetEntCntRequest   *message,
                      uint8_t             *out);
size_t rnd_get_ent_cnt_request__pack_to_buffer
                     (const RndGetEntCntRequest   *message,
                      ProtobufCBuffer     *buffer);
RndGetEntCntRequest *
       rnd_get_ent_cnt_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rnd_get_ent_cnt_request__free_unpacked
                     (RndGetEntCntRequest *message,
                      ProtobufCAllocator *allocator);
/* RndGetEntCntResponse methods */
void   rnd_get_ent_cnt_response__init
                     (RndGetEntCntResponse         *message);
size_t rnd_get_ent_cnt_response__get_packed_size
                     (const RndGetEntCntResponse   *message);
size_t rnd_get_ent_cnt_response__pack
                     (const RndGetEntCntResponse   *message,
                      uint8_t             *out);
size_t rnd_get_ent_cnt_response__pack_to_buffer
                     (const RndGetEntCntResponse   *message,
                      ProtobufCBuffer     *buffer);
RndGetEntCntResponse *
       rnd_get_ent_cnt_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rnd_get_ent_cnt_response__free_unpacked
                     (RndGetEntCntResponse *message,
                      ProtobufCAllocator *allocator);
/* GetPoolsizeRequest methods */
void   get_poolsize_request__init
                     (GetPoolsizeRequest         *message);
size_t get_poolsize_request__get_packed_size
                     (const GetPoolsizeRequest   *message);
size_t get_poolsize_request__pack
                     (const GetPoolsizeRequest   *message,
                      uint8_t             *out);
size_t get_poolsize_request__pack_to_buffer
                     (const GetPoolsizeRequest   *message,
                      ProtobufCBuffer     *buffer);
GetPoolsizeRequest *
       get_poolsize_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_poolsize_request__free_unpacked
                     (GetPoolsizeRequest *message,
                      ProtobufCAllocator *allocator);
/* GetPoolsizeResponse methods */
void   get_poolsize_response__init
                     (GetPoolsizeResponse         *message);
size_t get_poolsize_response__get_packed_size
                     (const GetPoolsizeResponse   *message);
size_t get_poolsize_response__pack
                     (const GetPoolsizeResponse   *message,
                      uint8_t             *out);
size_t get_poolsize_response__pack_to_buffer
                     (const GetPoolsizeResponse   *message,
                      ProtobufCBuffer     *buffer);
GetPoolsizeResponse *
       get_poolsize_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_poolsize_response__free_unpacked
                     (GetPoolsizeResponse *message,
                      ProtobufCAllocator *allocator);
/* GetWriteWakeupThreshRequest methods */
void   get_write_wakeup_thresh_request__init
                     (GetWriteWakeupThreshRequest         *message);
size_t get_write_wakeup_thresh_request__get_packed_size
                     (const GetWriteWakeupThreshRequest   *message);
size_t get_write_wakeup_thresh_request__pack
                     (const GetWriteWakeupThreshRequest   *message,
                      uint8_t             *out);
size_t get_write_wakeup_thresh_request__pack_to_buffer
                     (const GetWriteWakeupThreshRequest   *message,
                      ProtobufCBuffer     *buffer);
GetWriteWakeupThreshRequest *
       get_write_wakeup_thresh_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_write_wakeup_thresh_request__free_unpacked
                     (GetWriteWakeupThreshRequest *message,
                      ProtobufCAllocator *allocator);
/* GetWriteWakeupThreshResponse methods */
void   get_write_wakeup_thresh_response__init
                     (GetWriteWakeupThreshResponse         *message);
size_t get_write_wakeup_thresh_response__get_packed_size
                     (const GetWriteWakeupThreshResponse   *message);
size_t get_write_wakeup_thresh_response__pack
                     (const GetWriteWakeupThreshResponse   *message,
                      uint8_t             *out);
size_t get_write_wakeup_thresh_response__pack_to_buffer
                     (const GetWriteWakeupThreshResponse   *message,
                      ProtobufCBuffer     *buffer);
GetWriteWakeupThreshResponse *
       get_write_wakeup_thresh_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_write_wakeup_thresh_response__free_unpacked
                     (GetWriteWakeupThreshResponse *message,
                      ProtobufCAllocator *allocator);
/* GetMinReseedSecsRequest methods */
void   get_min_reseed_secs_request__init
                     (GetMinReseedSecsRequest         *message);
size_t get_min_reseed_secs_request__get_packed_size
                     (const GetMinReseedSecsRequest   *message);
size_t get_min_reseed_secs_request__pack
                     (const GetMinReseedSecsRequest   *message,
                      uint8_t             *out);
size_t get_min_reseed_secs_request__pack_to_buffer
                     (const GetMinReseedSecsRequest   *message,
                      ProtobufCBuffer     *buffer);
GetMinReseedSecsRequest *
       get_min_reseed_secs_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_min_reseed_secs_request__free_unpacked
                     (GetMinReseedSecsRequest *message,
                      ProtobufCAllocator *allocator);
/* GetMinReseedSecsResponse methods */
void   get_min_reseed_secs_response__init
                     (GetMinReseedSecsResponse         *message);
size_t get_min_reseed_secs_response__get_packed_size
                     (const GetMinReseedSecsResponse   *message);
size_t get_min_reseed_secs_response__pack
                     (const GetMinReseedSecsResponse   *message,
                      uint8_t             *out);
size_t get_min_reseed_secs_response__pack_to_buffer
                     (const GetMinReseedSecsResponse   *message,
                      ProtobufCBuffer     *buffer);
GetMinReseedSecsResponse *
       get_min_reseed_secs_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   get_min_reseed_secs_response__free_unpacked
                     (GetMinReseedSecsResponse *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*StatusRequest_Closure)
                 (const StatusRequest *message,
                  void *closure_data);
typedef void (*StatusResponse_Closure)
                 (const StatusResponse *message,
                  void *closure_data);
typedef void (*JentStatusRequest_Closure)
                 (const JentStatusRequest *message,
                  void *closure_data);
typedef void (*JentStatusResponse_Closure)
                 (const JentStatusResponse *message,
                  void *closure_data);
typedef void (*GetEntLvlRequest_Closure)
                 (const GetEntLvlRequest *message,
                  void *closure_data);
typedef void (*GetEntLvlResponse_Closure)
                 (const GetEntLvlResponse *message,
                  void *closure_data);
typedef void (*IsFullySeededRequest_Closure)
                 (const IsFullySeededRequest *message,
                  void *closure_data);
typedef void (*IsFullySeededResponse_Closure)
                 (const IsFullySeededResponse *message,
                  void *closure_data);
typedef void (*GetRandomBytesFullRequest_Closure)
                 (const GetRandomBytesFullRequest *message,
                  void *closure_data);
typedef void (*GetRandomBytesFullResponse_Closure)
                 (const GetRandomBytesFullResponse *message,
                  void *closure_data);
typedef void (*GetRandomBytesPrRequest_Closure)
                 (const GetRandomBytesPrRequest *message,
                  void *closure_data);
typedef void (*GetRandomBytesPrResponse_Closure)
                 (const GetRandomBytesPrResponse *message,
                  void *closure_data);
typedef void (*GetSeedRequest_Closure)
                 (const GetSeedRequest *message,
                  void *closure_data);
typedef void (*GetSeedResponse_Closure)
                 (const GetSeedResponse *message,
                  void *closure_data);
typedef void (*GetRandomBytesRequest_Closure)
                 (const GetRandomBytesRequest *message,
                  void *closure_data);
typedef void (*GetRandomBytesResponse_Closure)
                 (const GetRandomBytesResponse *message,
                  void *closure_data);
typedef void (*WriteDataRequest_Closure)
                 (const WriteDataRequest *message,
                  void *closure_data);
typedef void (*WriteDataResponse_Closure)
                 (const WriteDataResponse *message,
                  void *closure_data);
typedef void (*RndGetEntCntRequest_Closure)
                 (const RndGetEntCntRequest *message,
                  void *closure_data);
typedef void (*RndGetEntCntResponse_Closure)
                 (const RndGetEntCntResponse *message,
                  void *closure_data);
typedef void (*GetPoolsizeRequest_Closure)
                 (const GetPoolsizeRequest *message,
                  void *closure_data);
typedef void (*GetPoolsizeResponse_Closure)
                 (const GetPoolsizeResponse *message,
                  void *closure_data);
typedef void (*GetWriteWakeupThreshRequest_Closure)
                 (const GetWriteWakeupThreshRequest *message,
                  void *closure_data);
typedef void (*GetWriteWakeupThreshResponse_Closure)
                 (const GetWriteWakeupThreshResponse *message,
                  void *closure_data);
typedef void (*GetMinReseedSecsRequest_Closure)
                 (const GetMinReseedSecsRequest *message,
                  void *closure_data);
typedef void (*GetMinReseedSecsResponse_Closure)
                 (const GetMinReseedSecsResponse *message,
                  void *closure_data);

/* --- services --- */

typedef struct UnprivAccess_Service UnprivAccess_Service;
struct UnprivAccess_Service
{
  ProtobufCService base;
  void (*rpc_status)(UnprivAccess_Service *service,
                     const StatusRequest *input,
                     StatusResponse_Closure closure,
                     void *closure_data);
  void (*rpc_get_ent_lvl)(UnprivAccess_Service *service,
                          const GetEntLvlRequest *input,
                          GetEntLvlResponse_Closure closure,
                          void *closure_data);
  void (*rpc_is_fully_seeded)(UnprivAccess_Service *service,
                              const IsFullySeededRequest *input,
                              IsFullySeededResponse_Closure closure,
                              void *closure_data);
  void (*rpc_get_random_bytes_full)(UnprivAccess_Service *service,
                                    const GetRandomBytesFullRequest *input,
                                    GetRandomBytesFullResponse_Closure closure,
                                    void *closure_data);
  void (*rpc_get_random_bytes_pr)(UnprivAccess_Service *service,
                                  const GetRandomBytesPrRequest *input,
                                  GetRandomBytesPrResponse_Closure closure,
                                  void *closure_data);
  void (*rpc_get_random_bytes)(UnprivAccess_Service *service,
                               const GetRandomBytesRequest *input,
                               GetRandomBytesResponse_Closure closure,
                               void *closure_data);
  void (*rpc_get_seed)(UnprivAccess_Service *service,
                       const GetSeedRequest *input,
                       GetSeedResponse_Closure closure,
                       void *closure_data);
  void (*rpc_write_data)(UnprivAccess_Service *service,
                         const WriteDataRequest *input,
                         WriteDataResponse_Closure closure,
                         void *closure_data);
  void (*rpc_rnd_get_ent_cnt)(UnprivAccess_Service *service,
                              const RndGetEntCntRequest *input,
                              RndGetEntCntResponse_Closure closure,
                              void *closure_data);
  void (*rpc_get_poolsize)(UnprivAccess_Service *service,
                           const GetPoolsizeRequest *input,
                           GetPoolsizeResponse_Closure closure,
                           void *closure_data);
  void (*rpc_get_write_wakeup_thresh)(UnprivAccess_Service *service,
                                      const GetWriteWakeupThreshRequest *input,
                                      GetWriteWakeupThreshResponse_Closure closure,
                                      void *closure_data);
  void (*rpc_get_min_reseed_secs)(UnprivAccess_Service *service,
                                  const GetMinReseedSecsRequest *input,
                                  GetMinReseedSecsResponse_Closure closure,
                                  void *closure_data);
  void (*rpc_jent_status)(UnprivAccess_Service *service,
                          const JentStatusRequest *input,
                          JentStatusResponse_Closure closure,
                          void *closure_data);
};
typedef void (*UnprivAccess_ServiceDestroy)(UnprivAccess_Service *);
void unpriv_access__init (UnprivAccess_Service *service,
                          UnprivAccess_ServiceDestroy destroy);
#define UNPRIV_ACCESS__BASE_INIT \
    { &unpriv_access__descriptor, protobuf_c_service_invoke_internal, NULL }
#define UNPRIV_ACCESS__INIT(function_prefix__) \
    { UNPRIV_ACCESS__BASE_INIT,\
      function_prefix__ ## rpc_status,\
      function_prefix__ ## rpc_get_ent_lvl,\
      function_prefix__ ## rpc_is_fully_seeded,\
      function_prefix__ ## rpc_get_random_bytes_full,\
      function_prefix__ ## rpc_get_random_bytes_pr,\
      function_prefix__ ## rpc_get_random_bytes,\
      function_prefix__ ## rpc_get_seed,\
      function_prefix__ ## rpc_write_data,\
      function_prefix__ ## rpc_rnd_get_ent_cnt,\
      function_prefix__ ## rpc_get_poolsize,\
      function_prefix__ ## rpc_get_write_wakeup_thresh,\
      function_prefix__ ## rpc_get_min_reseed_secs,\
      function_prefix__ ## rpc_jent_status  }
void unpriv_access__rpc_status(ProtobufCService *service,
                               const StatusRequest *input,
                               StatusResponse_Closure closure,
                               void *closure_data);
void unpriv_access__rpc_get_ent_lvl(ProtobufCService *service,
                                    const GetEntLvlRequest *input,
                                    GetEntLvlResponse_Closure closure,
                                    void *closure_data);
void unpriv_access__rpc_is_fully_seeded(ProtobufCService *service,
                                        const IsFullySeededRequest *input,
                                        IsFullySeededResponse_Closure closure,
                                        void *closure_data);
void unpriv_access__rpc_get_random_bytes_full(ProtobufCService *service,
                                              const GetRandomBytesFullRequest *input,
                                              GetRandomBytesFullResponse_Closure closure,
                                              void *closure_data);
void unpriv_access__rpc_get_random_bytes_pr(ProtobufCService *service,
                                            const GetRandomBytesPrRequest *input,
                                            GetRandomBytesPrResponse_Closure closure,
                                            void *closure_data);
void unpriv_access__rpc_get_random_bytes(ProtobufCService *service,
                                         const GetRandomBytesRequest *input,
                                         GetRandomBytesResponse_Closure closure,
                                         void *closure_data);
void unpriv_access__rpc_get_seed(ProtobufCService *service,
                                 const GetSeedRequest *input,
                                 GetSeedResponse_Closure closure,
                                 void *closure_data);
void unpriv_access__rpc_write_data(ProtobufCService *service,
                                   const WriteDataRequest *input,
                                   WriteDataResponse_Closure closure,
                                   void *closure_data);
void unpriv_access__rpc_rnd_get_ent_cnt(ProtobufCService *service,
                                        const RndGetEntCntRequest *input,
                                        RndGetEntCntResponse_Closure closure,
                                        void *closure_data);
void unpriv_access__rpc_get_poolsize(ProtobufCService *service,
                                     const GetPoolsizeRequest *input,
                                     GetPoolsizeResponse_Closure closure,
                                     void *closure_data);
void unpriv_access__rpc_get_write_wakeup_thresh(ProtobufCService *service,
                                                const GetWriteWakeupThreshRequest *input,
                                                GetWriteWakeupThreshResponse_Closure closure,
                                                void *closure_data);
void unpriv_access__rpc_get_min_reseed_secs(ProtobufCService *service,
                                            const GetMinReseedSecsRequest *input,
                                            GetMinReseedSecsResponse_Closure closure,
                                            void *closure_data);
void unpriv_access__rpc_jent_status(ProtobufCService *service,
                                    const JentStatusRequest *input,
                                    JentStatusResponse_Closure closure,
                                    void *closure_data);

/* --- descriptors --- */

extern const ProtobufCMessageDescriptor status_request__descriptor;
extern const ProtobufCMessageDescriptor status_response__descriptor;
extern const ProtobufCMessageDescriptor jent_status_request__descriptor;
extern const ProtobufCMessageDescriptor jent_status_response__descriptor;
extern const ProtobufCMessageDescriptor get_ent_lvl_request__descriptor;
extern const ProtobufCMessageDescriptor get_ent_lvl_response__descriptor;
extern const ProtobufCMessageDescriptor is_fully_seeded_request__descriptor;
extern const ProtobufCMessageDescriptor is_fully_seeded_response__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_full_request__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_full_response__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_pr_request__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_pr_response__descriptor;
extern const ProtobufCMessageDescriptor get_seed_request__descriptor;
extern const ProtobufCMessageDescriptor get_seed_response__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_request__descriptor;
extern const ProtobufCMessageDescriptor get_random_bytes_response__descriptor;
extern const ProtobufCMessageDescriptor write_data_request__descriptor;
extern const ProtobufCMessageDescriptor write_data_response__descriptor;
extern const ProtobufCMessageDescriptor rnd_get_ent_cnt_request__descriptor;
extern const ProtobufCMessageDescriptor rnd_get_ent_cnt_response__descriptor;
extern const ProtobufCMessageDescriptor get_poolsize_request__descriptor;
extern const ProtobufCMessageDescriptor get_poolsize_response__descriptor;
extern const ProtobufCMessageDescriptor get_write_wakeup_thresh_request__descriptor;
extern const ProtobufCMessageDescriptor get_write_wakeup_thresh_response__descriptor;
extern const ProtobufCMessageDescriptor get_min_reseed_secs_request__descriptor;
extern const ProtobufCMessageDescriptor get_min_reseed_secs_response__descriptor;
extern const ProtobufCServiceDescriptor unpriv_access__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_unpriv_5faccess_2eproto__INCLUDED */
