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

/* Do not generate deprecated warnings for self */
#ifndef PROTOBUF_C__NO_DEPRECATED
#define PROTOBUF_C__NO_DEPRECATED
#endif

#include "ipc.pb-c.h"
void   auth_cookie_request_msg__init
                     (AuthCookieRequestMsg         *message)
{
  static const AuthCookieRequestMsg init_value = AUTH_COOKIE_REQUEST_MSG__INIT;
  *message = init_value;
}
size_t auth_cookie_request_msg__get_packed_size
                     (const AuthCookieRequestMsg *message)
{
  assert(message->base.descriptor == &auth_cookie_request_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t auth_cookie_request_msg__pack
                     (const AuthCookieRequestMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &auth_cookie_request_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t auth_cookie_request_msg__pack_to_buffer
                     (const AuthCookieRequestMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &auth_cookie_request_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
AuthCookieRequestMsg *
       auth_cookie_request_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (AuthCookieRequestMsg *)
     protobuf_c_message_unpack (&auth_cookie_request_msg__descriptor,
                                allocator, len, data);
}
void   auth_cookie_request_msg__free_unpacked
                     (AuthCookieRequestMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &auth_cookie_request_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   fw_port_st__init
                     (FwPortSt         *message)
{
  static const FwPortSt init_value = FW_PORT_ST__INIT;
  *message = init_value;
}
size_t fw_port_st__get_packed_size
                     (const FwPortSt *message)
{
  assert(message->base.descriptor == &fw_port_st__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t fw_port_st__pack
                     (const FwPortSt *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &fw_port_st__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t fw_port_st__pack_to_buffer
                     (const FwPortSt *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &fw_port_st__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
FwPortSt *
       fw_port_st__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (FwPortSt *)
     protobuf_c_message_unpack (&fw_port_st__descriptor,
                                allocator, len, data);
}
void   fw_port_st__free_unpacked
                     (FwPortSt *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &fw_port_st__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   group_cfg_st__init
                     (GroupCfgSt         *message)
{
  static const GroupCfgSt init_value = GROUP_CFG_ST__INIT;
  *message = init_value;
}
size_t group_cfg_st__get_packed_size
                     (const GroupCfgSt *message)
{
  assert(message->base.descriptor == &group_cfg_st__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t group_cfg_st__pack
                     (const GroupCfgSt *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &group_cfg_st__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t group_cfg_st__pack_to_buffer
                     (const GroupCfgSt *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &group_cfg_st__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
GroupCfgSt *
       group_cfg_st__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (GroupCfgSt *)
     protobuf_c_message_unpack (&group_cfg_st__descriptor,
                                allocator, len, data);
}
void   group_cfg_st__free_unpacked
                     (GroupCfgSt *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &group_cfg_st__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   auth_cookie_reply_msg__init
                     (AuthCookieReplyMsg         *message)
{
  static const AuthCookieReplyMsg init_value = AUTH_COOKIE_REPLY_MSG__INIT;
  *message = init_value;
}
size_t auth_cookie_reply_msg__get_packed_size
                     (const AuthCookieReplyMsg *message)
{
  assert(message->base.descriptor == &auth_cookie_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t auth_cookie_reply_msg__pack
                     (const AuthCookieReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &auth_cookie_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t auth_cookie_reply_msg__pack_to_buffer
                     (const AuthCookieReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &auth_cookie_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
AuthCookieReplyMsg *
       auth_cookie_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (AuthCookieReplyMsg *)
     protobuf_c_message_unpack (&auth_cookie_reply_msg__descriptor,
                                allocator, len, data);
}
void   auth_cookie_reply_msg__free_unpacked
                     (AuthCookieReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &auth_cookie_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   session_resume_fetch_msg__init
                     (SessionResumeFetchMsg         *message)
{
  static const SessionResumeFetchMsg init_value = SESSION_RESUME_FETCH_MSG__INIT;
  *message = init_value;
}
size_t session_resume_fetch_msg__get_packed_size
                     (const SessionResumeFetchMsg *message)
{
  assert(message->base.descriptor == &session_resume_fetch_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t session_resume_fetch_msg__pack
                     (const SessionResumeFetchMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &session_resume_fetch_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t session_resume_fetch_msg__pack_to_buffer
                     (const SessionResumeFetchMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &session_resume_fetch_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SessionResumeFetchMsg *
       session_resume_fetch_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SessionResumeFetchMsg *)
     protobuf_c_message_unpack (&session_resume_fetch_msg__descriptor,
                                allocator, len, data);
}
void   session_resume_fetch_msg__free_unpacked
                     (SessionResumeFetchMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &session_resume_fetch_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   session_resume_store_req_msg__init
                     (SessionResumeStoreReqMsg         *message)
{
  static const SessionResumeStoreReqMsg init_value = SESSION_RESUME_STORE_REQ_MSG__INIT;
  *message = init_value;
}
size_t session_resume_store_req_msg__get_packed_size
                     (const SessionResumeStoreReqMsg *message)
{
  assert(message->base.descriptor == &session_resume_store_req_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t session_resume_store_req_msg__pack
                     (const SessionResumeStoreReqMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &session_resume_store_req_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t session_resume_store_req_msg__pack_to_buffer
                     (const SessionResumeStoreReqMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &session_resume_store_req_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SessionResumeStoreReqMsg *
       session_resume_store_req_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SessionResumeStoreReqMsg *)
     protobuf_c_message_unpack (&session_resume_store_req_msg__descriptor,
                                allocator, len, data);
}
void   session_resume_store_req_msg__free_unpacked
                     (SessionResumeStoreReqMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &session_resume_store_req_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   session_resume_reply_msg__init
                     (SessionResumeReplyMsg         *message)
{
  static const SessionResumeReplyMsg init_value = SESSION_RESUME_REPLY_MSG__INIT;
  *message = init_value;
}
size_t session_resume_reply_msg__get_packed_size
                     (const SessionResumeReplyMsg *message)
{
  assert(message->base.descriptor == &session_resume_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t session_resume_reply_msg__pack
                     (const SessionResumeReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &session_resume_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t session_resume_reply_msg__pack_to_buffer
                     (const SessionResumeReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &session_resume_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SessionResumeReplyMsg *
       session_resume_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SessionResumeReplyMsg *)
     protobuf_c_message_unpack (&session_resume_reply_msg__descriptor,
                                allocator, len, data);
}
void   session_resume_reply_msg__free_unpacked
                     (SessionResumeReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &session_resume_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   tun_mtu_msg__init
                     (TunMtuMsg         *message)
{
  static const TunMtuMsg init_value = TUN_MTU_MSG__INIT;
  *message = init_value;
}
size_t tun_mtu_msg__get_packed_size
                     (const TunMtuMsg *message)
{
  assert(message->base.descriptor == &tun_mtu_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t tun_mtu_msg__pack
                     (const TunMtuMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &tun_mtu_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t tun_mtu_msg__pack_to_buffer
                     (const TunMtuMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &tun_mtu_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
TunMtuMsg *
       tun_mtu_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (TunMtuMsg *)
     protobuf_c_message_unpack (&tun_mtu_msg__descriptor,
                                allocator, len, data);
}
void   tun_mtu_msg__free_unpacked
                     (TunMtuMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &tun_mtu_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   cli_stats_msg__init
                     (CliStatsMsg         *message)
{
  static const CliStatsMsg init_value = CLI_STATS_MSG__INIT;
  *message = init_value;
}
size_t cli_stats_msg__get_packed_size
                     (const CliStatsMsg *message)
{
  assert(message->base.descriptor == &cli_stats_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t cli_stats_msg__pack
                     (const CliStatsMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &cli_stats_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t cli_stats_msg__pack_to_buffer
                     (const CliStatsMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &cli_stats_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
CliStatsMsg *
       cli_stats_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (CliStatsMsg *)
     protobuf_c_message_unpack (&cli_stats_msg__descriptor,
                                allocator, len, data);
}
void   cli_stats_msg__free_unpacked
                     (CliStatsMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &cli_stats_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   udp_fd_msg__init
                     (UdpFdMsg         *message)
{
  static const UdpFdMsg init_value = UDP_FD_MSG__INIT;
  *message = init_value;
}
size_t udp_fd_msg__get_packed_size
                     (const UdpFdMsg *message)
{
  assert(message->base.descriptor == &udp_fd_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t udp_fd_msg__pack
                     (const UdpFdMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &udp_fd_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t udp_fd_msg__pack_to_buffer
                     (const UdpFdMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &udp_fd_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
UdpFdMsg *
       udp_fd_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (UdpFdMsg *)
     protobuf_c_message_unpack (&udp_fd_msg__descriptor,
                                allocator, len, data);
}
void   udp_fd_msg__free_unpacked
                     (UdpFdMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &udp_fd_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   snapshot_entry_msg__init
                     (SnapshotEntryMsg         *message)
{
  static const SnapshotEntryMsg init_value = SNAPSHOT_ENTRY_MSG__INIT;
  *message = init_value;
}
size_t snapshot_entry_msg__get_packed_size
                     (const SnapshotEntryMsg *message)
{
  assert(message->base.descriptor == &snapshot_entry_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t snapshot_entry_msg__pack
                     (const SnapshotEntryMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &snapshot_entry_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t snapshot_entry_msg__pack_to_buffer
                     (const SnapshotEntryMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &snapshot_entry_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SnapshotEntryMsg *
       snapshot_entry_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SnapshotEntryMsg *)
     protobuf_c_message_unpack (&snapshot_entry_msg__descriptor,
                                allocator, len, data);
}
void   snapshot_entry_msg__free_unpacked
                     (SnapshotEntryMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &snapshot_entry_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   worker_startup_msg__init
                     (WorkerStartupMsg         *message)
{
  static const WorkerStartupMsg init_value = WORKER_STARTUP_MSG__INIT;
  *message = init_value;
}
size_t worker_startup_msg__get_packed_size
                     (const WorkerStartupMsg *message)
{
  assert(message->base.descriptor == &worker_startup_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t worker_startup_msg__pack
                     (const WorkerStartupMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &worker_startup_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t worker_startup_msg__pack_to_buffer
                     (const WorkerStartupMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &worker_startup_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
WorkerStartupMsg *
       worker_startup_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (WorkerStartupMsg *)
     protobuf_c_message_unpack (&worker_startup_msg__descriptor,
                                allocator, len, data);
}
void   worker_startup_msg__free_unpacked
                     (WorkerStartupMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &worker_startup_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   session_info_msg__init
                     (SessionInfoMsg         *message)
{
  static const SessionInfoMsg init_value = SESSION_INFO_MSG__INIT;
  *message = init_value;
}
size_t session_info_msg__get_packed_size
                     (const SessionInfoMsg *message)
{
  assert(message->base.descriptor == &session_info_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t session_info_msg__pack
                     (const SessionInfoMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &session_info_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t session_info_msg__pack_to_buffer
                     (const SessionInfoMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &session_info_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SessionInfoMsg *
       session_info_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SessionInfoMsg *)
     protobuf_c_message_unpack (&session_info_msg__descriptor,
                                allocator, len, data);
}
void   session_info_msg__free_unpacked
                     (SessionInfoMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &session_info_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   ban_ip_msg__init
                     (BanIpMsg         *message)
{
  static const BanIpMsg init_value = BAN_IP_MSG__INIT;
  *message = init_value;
}
size_t ban_ip_msg__get_packed_size
                     (const BanIpMsg *message)
{
  assert(message->base.descriptor == &ban_ip_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t ban_ip_msg__pack
                     (const BanIpMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &ban_ip_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t ban_ip_msg__pack_to_buffer
                     (const BanIpMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &ban_ip_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
BanIpMsg *
       ban_ip_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (BanIpMsg *)
     protobuf_c_message_unpack (&ban_ip_msg__descriptor,
                                allocator, len, data);
}
void   ban_ip_msg__free_unpacked
                     (BanIpMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &ban_ip_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   ban_ip_reply_msg__init
                     (BanIpReplyMsg         *message)
{
  static const BanIpReplyMsg init_value = BAN_IP_REPLY_MSG__INIT;
  *message = init_value;
}
size_t ban_ip_reply_msg__get_packed_size
                     (const BanIpReplyMsg *message)
{
  assert(message->base.descriptor == &ban_ip_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t ban_ip_reply_msg__pack
                     (const BanIpReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &ban_ip_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t ban_ip_reply_msg__pack_to_buffer
                     (const BanIpReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &ban_ip_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
BanIpReplyMsg *
       ban_ip_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (BanIpReplyMsg *)
     protobuf_c_message_unpack (&ban_ip_reply_msg__descriptor,
                                allocator, len, data);
}
void   ban_ip_reply_msg__free_unpacked
                     (BanIpReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &ban_ip_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   latency_stats_delta__init
                     (LatencyStatsDelta         *message)
{
  static const LatencyStatsDelta init_value = LATENCY_STATS_DELTA__INIT;
  *message = init_value;
}
size_t latency_stats_delta__get_packed_size
                     (const LatencyStatsDelta *message)
{
  assert(message->base.descriptor == &latency_stats_delta__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t latency_stats_delta__pack
                     (const LatencyStatsDelta *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &latency_stats_delta__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t latency_stats_delta__pack_to_buffer
                     (const LatencyStatsDelta *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &latency_stats_delta__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
LatencyStatsDelta *
       latency_stats_delta__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (LatencyStatsDelta *)
     protobuf_c_message_unpack (&latency_stats_delta__descriptor,
                                allocator, len, data);
}
void   latency_stats_delta__free_unpacked
                     (LatencyStatsDelta *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &latency_stats_delta__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   sec_auth_init_msg__init
                     (SecAuthInitMsg         *message)
{
  static const SecAuthInitMsg init_value = SEC_AUTH_INIT_MSG__INIT;
  *message = init_value;
}
size_t sec_auth_init_msg__get_packed_size
                     (const SecAuthInitMsg *message)
{
  assert(message->base.descriptor == &sec_auth_init_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t sec_auth_init_msg__pack
                     (const SecAuthInitMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &sec_auth_init_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t sec_auth_init_msg__pack_to_buffer
                     (const SecAuthInitMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &sec_auth_init_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecAuthInitMsg *
       sec_auth_init_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecAuthInitMsg *)
     protobuf_c_message_unpack (&sec_auth_init_msg__descriptor,
                                allocator, len, data);
}
void   sec_auth_init_msg__free_unpacked
                     (SecAuthInitMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &sec_auth_init_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   sec_auth_cont_msg__init
                     (SecAuthContMsg         *message)
{
  static const SecAuthContMsg init_value = SEC_AUTH_CONT_MSG__INIT;
  *message = init_value;
}
size_t sec_auth_cont_msg__get_packed_size
                     (const SecAuthContMsg *message)
{
  assert(message->base.descriptor == &sec_auth_cont_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t sec_auth_cont_msg__pack
                     (const SecAuthContMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &sec_auth_cont_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t sec_auth_cont_msg__pack_to_buffer
                     (const SecAuthContMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &sec_auth_cont_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecAuthContMsg *
       sec_auth_cont_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecAuthContMsg *)
     protobuf_c_message_unpack (&sec_auth_cont_msg__descriptor,
                                allocator, len, data);
}
void   sec_auth_cont_msg__free_unpacked
                     (SecAuthContMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &sec_auth_cont_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   sec_auth_reply_msg__init
                     (SecAuthReplyMsg         *message)
{
  static const SecAuthReplyMsg init_value = SEC_AUTH_REPLY_MSG__INIT;
  *message = init_value;
}
size_t sec_auth_reply_msg__get_packed_size
                     (const SecAuthReplyMsg *message)
{
  assert(message->base.descriptor == &sec_auth_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t sec_auth_reply_msg__pack
                     (const SecAuthReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &sec_auth_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t sec_auth_reply_msg__pack_to_buffer
                     (const SecAuthReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &sec_auth_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecAuthReplyMsg *
       sec_auth_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecAuthReplyMsg *)
     protobuf_c_message_unpack (&sec_auth_reply_msg__descriptor,
                                allocator, len, data);
}
void   sec_auth_reply_msg__free_unpacked
                     (SecAuthReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &sec_auth_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   sec_op_msg__init
                     (SecOpMsg         *message)
{
  static const SecOpMsg init_value = SEC_OP_MSG__INIT;
  *message = init_value;
}
size_t sec_op_msg__get_packed_size
                     (const SecOpMsg *message)
{
  assert(message->base.descriptor == &sec_op_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t sec_op_msg__pack
                     (const SecOpMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &sec_op_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t sec_op_msg__pack_to_buffer
                     (const SecOpMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &sec_op_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecOpMsg *
       sec_op_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecOpMsg *)
     protobuf_c_message_unpack (&sec_op_msg__descriptor,
                                allocator, len, data);
}
void   sec_op_msg__free_unpacked
                     (SecOpMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &sec_op_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   sec_get_pk_msg__init
                     (SecGetPkMsg         *message)
{
  static const SecGetPkMsg init_value = SEC_GET_PK_MSG__INIT;
  *message = init_value;
}
size_t sec_get_pk_msg__get_packed_size
                     (const SecGetPkMsg *message)
{
  assert(message->base.descriptor == &sec_get_pk_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t sec_get_pk_msg__pack
                     (const SecGetPkMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &sec_get_pk_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t sec_get_pk_msg__pack_to_buffer
                     (const SecGetPkMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &sec_get_pk_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecGetPkMsg *
       sec_get_pk_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecGetPkMsg *)
     protobuf_c_message_unpack (&sec_get_pk_msg__descriptor,
                                allocator, len, data);
}
void   sec_get_pk_msg__free_unpacked
                     (SecGetPkMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &sec_get_pk_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   secm_session_open_msg__init
                     (SecmSessionOpenMsg         *message)
{
  static const SecmSessionOpenMsg init_value = SECM_SESSION_OPEN_MSG__INIT;
  *message = init_value;
}
size_t secm_session_open_msg__get_packed_size
                     (const SecmSessionOpenMsg *message)
{
  assert(message->base.descriptor == &secm_session_open_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t secm_session_open_msg__pack
                     (const SecmSessionOpenMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &secm_session_open_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t secm_session_open_msg__pack_to_buffer
                     (const SecmSessionOpenMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &secm_session_open_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecmSessionOpenMsg *
       secm_session_open_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecmSessionOpenMsg *)
     protobuf_c_message_unpack (&secm_session_open_msg__descriptor,
                                allocator, len, data);
}
void   secm_session_open_msg__free_unpacked
                     (SecmSessionOpenMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &secm_session_open_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   secm_session_close_msg__init
                     (SecmSessionCloseMsg         *message)
{
  static const SecmSessionCloseMsg init_value = SECM_SESSION_CLOSE_MSG__INIT;
  *message = init_value;
}
size_t secm_session_close_msg__get_packed_size
                     (const SecmSessionCloseMsg *message)
{
  assert(message->base.descriptor == &secm_session_close_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t secm_session_close_msg__pack
                     (const SecmSessionCloseMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &secm_session_close_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t secm_session_close_msg__pack_to_buffer
                     (const SecmSessionCloseMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &secm_session_close_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecmSessionCloseMsg *
       secm_session_close_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecmSessionCloseMsg *)
     protobuf_c_message_unpack (&secm_session_close_msg__descriptor,
                                allocator, len, data);
}
void   secm_session_close_msg__free_unpacked
                     (SecmSessionCloseMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &secm_session_close_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   secm_stats_msg__init
                     (SecmStatsMsg         *message)
{
  static const SecmStatsMsg init_value = SECM_STATS_MSG__INIT;
  *message = init_value;
}
size_t secm_stats_msg__get_packed_size
                     (const SecmStatsMsg *message)
{
  assert(message->base.descriptor == &secm_stats_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t secm_stats_msg__pack
                     (const SecmStatsMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &secm_stats_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t secm_stats_msg__pack_to_buffer
                     (const SecmStatsMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &secm_stats_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecmStatsMsg *
       secm_stats_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecmStatsMsg *)
     protobuf_c_message_unpack (&secm_stats_msg__descriptor,
                                allocator, len, data);
}
void   secm_stats_msg__free_unpacked
                     (SecmStatsMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &secm_stats_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   secm_session_reply_msg__init
                     (SecmSessionReplyMsg         *message)
{
  static const SecmSessionReplyMsg init_value = SECM_SESSION_REPLY_MSG__INIT;
  *message = init_value;
}
size_t secm_session_reply_msg__get_packed_size
                     (const SecmSessionReplyMsg *message)
{
  assert(message->base.descriptor == &secm_session_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t secm_session_reply_msg__pack
                     (const SecmSessionReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &secm_session_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t secm_session_reply_msg__pack_to_buffer
                     (const SecmSessionReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &secm_session_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecmSessionReplyMsg *
       secm_session_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecmSessionReplyMsg *)
     protobuf_c_message_unpack (&secm_session_reply_msg__descriptor,
                                allocator, len, data);
}
void   secm_session_reply_msg__free_unpacked
                     (SecmSessionReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &secm_session_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   cookie_int_msg__init
                     (CookieIntMsg         *message)
{
  static const CookieIntMsg init_value = COOKIE_INT_MSG__INIT;
  *message = init_value;
}
size_t cookie_int_msg__get_packed_size
                     (const CookieIntMsg *message)
{
  assert(message->base.descriptor == &cookie_int_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t cookie_int_msg__pack
                     (const CookieIntMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &cookie_int_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t cookie_int_msg__pack_to_buffer
                     (const CookieIntMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &cookie_int_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
CookieIntMsg *
       cookie_int_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (CookieIntMsg *)
     protobuf_c_message_unpack (&cookie_int_msg__descriptor,
                                allocator, len, data);
}
void   cookie_int_msg__free_unpacked
                     (CookieIntMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &cookie_int_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   secm_list_cookies_reply_msg__init
                     (SecmListCookiesReplyMsg         *message)
{
  static const SecmListCookiesReplyMsg init_value = SECM_LIST_COOKIES_REPLY_MSG__INIT;
  *message = init_value;
}
size_t secm_list_cookies_reply_msg__get_packed_size
                     (const SecmListCookiesReplyMsg *message)
{
  assert(message->base.descriptor == &secm_list_cookies_reply_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t secm_list_cookies_reply_msg__pack
                     (const SecmListCookiesReplyMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &secm_list_cookies_reply_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t secm_list_cookies_reply_msg__pack_to_buffer
                     (const SecmListCookiesReplyMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &secm_list_cookies_reply_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SecmListCookiesReplyMsg *
       secm_list_cookies_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SecmListCookiesReplyMsg *)
     protobuf_c_message_unpack (&secm_list_cookies_reply_msg__descriptor,
                                allocator, len, data);
}
void   secm_list_cookies_reply_msg__free_unpacked
                     (SecmListCookiesReplyMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &secm_list_cookies_reply_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
void   snapshot_state_msg__init
                     (SnapshotStateMsg         *message)
{
  static const SnapshotStateMsg init_value = SNAPSHOT_STATE_MSG__INIT;
  *message = init_value;
}
size_t snapshot_state_msg__get_packed_size
                     (const SnapshotStateMsg *message)
{
  assert(message->base.descriptor == &snapshot_state_msg__descriptor);
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
}
size_t snapshot_state_msg__pack
                     (const SnapshotStateMsg *message,
                      uint8_t       *out)
{
  assert(message->base.descriptor == &snapshot_state_msg__descriptor);
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
}
size_t snapshot_state_msg__pack_to_buffer
                     (const SnapshotStateMsg *message,
                      ProtobufCBuffer *buffer)
{
  assert(message->base.descriptor == &snapshot_state_msg__descriptor);
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
}
SnapshotStateMsg *
       snapshot_state_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data)
{
  return (SnapshotStateMsg *)
     protobuf_c_message_unpack (&snapshot_state_msg__descriptor,
                                allocator, len, data);
}
void   snapshot_state_msg__free_unpacked
                     (SnapshotStateMsg *message,
                      ProtobufCAllocator *allocator)
{
  if(!message)
    return;
  assert(message->base.descriptor == &snapshot_state_msg__descriptor);
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
}
static const ProtobufCFieldDescriptor auth_cookie_request_msg__field_descriptors[2] =
{
  {
    "cookie",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(AuthCookieRequestMsg, cookie),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hostname",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieRequestMsg, hostname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned auth_cookie_request_msg__field_indices_by_name[] = {
  0,   /* field[0] = cookie */
  1,   /* field[1] = hostname */
};
static const ProtobufCIntRange auth_cookie_request_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor auth_cookie_request_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "auth_cookie_request_msg",
  "AuthCookieRequestMsg",
  "AuthCookieRequestMsg",
  "",
  sizeof(AuthCookieRequestMsg),
  2,
  auth_cookie_request_msg__field_descriptors,
  auth_cookie_request_msg__field_indices_by_name,
  1,  auth_cookie_request_msg__number_ranges,
  (ProtobufCMessageInit) auth_cookie_request_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor fw_port_st__field_descriptors[3] =
{
  {
    "port",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(FwPortSt, port),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "proto",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(FwPortSt, proto),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "negate",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(FwPortSt, negate),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned fw_port_st__field_indices_by_name[] = {
  2,   /* field[2] = negate */
  0,   /* field[0] = port */
  1,   /* field[1] = proto */
};
static const ProtobufCIntRange fw_port_st__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor fw_port_st__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "fw_port_st",
  "FwPortSt",
  "FwPortSt",
  "",
  sizeof(FwPortSt),
  3,
  fw_port_st__field_descriptors,
  fw_port_st__field_indices_by_name,
  1,  fw_port_st__number_ranges,
  (ProtobufCMessageInit) fw_port_st__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor group_cfg_st__field_descriptors[34] =
{
  {
    "interim_update_secs",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_interim_update_secs),
    offsetof(GroupCfgSt, interim_update_secs),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_timeout_secs",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_session_timeout_secs),
    offsetof(GroupCfgSt, session_timeout_secs),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "no_udp",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(GroupCfgSt, has_no_udp),
    offsetof(GroupCfgSt, no_udp),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "deny_roaming",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(GroupCfgSt, has_deny_roaming),
    offsetof(GroupCfgSt, deny_roaming),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "routes",
    13,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_routes),
    offsetof(GroupCfgSt, routes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "iroutes",
    14,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_iroutes),
    offsetof(GroupCfgSt, iroutes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dns",
    15,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_dns),
    offsetof(GroupCfgSt, dns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "nbns",
    16,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_nbns),
    offsetof(GroupCfgSt, nbns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4_net",
    17,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, ipv4_net),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4_netmask",
    18,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, ipv4_netmask),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6_net",
    19,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, ipv6_net),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6_prefix",
    20,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_ipv6_prefix),
    offsetof(GroupCfgSt, ipv6_prefix),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cgroup",
    21,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, cgroup),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "xml_config_file",
    22,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, xml_config_file),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rx_per_sec",
    23,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_rx_per_sec),
    offsetof(GroupCfgSt, rx_per_sec),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tx_per_sec",
    24,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_tx_per_sec),
    offsetof(GroupCfgSt, tx_per_sec),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "net_priority",
    25,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_net_priority),
    offsetof(GroupCfgSt, net_priority),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "explicit_ipv4",
    26,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, explicit_ipv4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "explicit_ipv6",
    27,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, explicit_ipv6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "no_routes",
    28,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_no_routes),
    offsetof(GroupCfgSt, no_routes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6_subnet_prefix",
    29,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_ipv6_subnet_prefix),
    offsetof(GroupCfgSt, ipv6_subnet_prefix),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dpd",
    30,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_dpd),
    offsetof(GroupCfgSt, dpd),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mobile_dpd",
    31,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_mobile_dpd),
    offsetof(GroupCfgSt, mobile_dpd),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "keepalive",
    32,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_keepalive),
    offsetof(GroupCfgSt, keepalive),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "max_same_clients",
    33,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_max_same_clients),
    offsetof(GroupCfgSt, max_same_clients),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tunnel_all_dns",
    34,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_tunnel_all_dns),
    offsetof(GroupCfgSt, tunnel_all_dns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "restrict_user_to_routes",
    35,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BOOL,
    offsetof(GroupCfgSt, has_restrict_user_to_routes),
    offsetof(GroupCfgSt, restrict_user_to_routes),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mtu",
    36,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_mtu),
    offsetof(GroupCfgSt, mtu),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "idle_timeout",
    37,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_idle_timeout),
    offsetof(GroupCfgSt, idle_timeout),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "mobile_idle_timeout",
    38,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_mobile_idle_timeout),
    offsetof(GroupCfgSt, mobile_idle_timeout),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "fw_ports",
    39,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(GroupCfgSt, n_fw_ports),
    offsetof(GroupCfgSt, fw_ports),
    &fw_port_st__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hostname",
    40,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(GroupCfgSt, hostname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "split_dns",
    41,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(GroupCfgSt, n_split_dns),
    offsetof(GroupCfgSt, split_dns),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "client_bypass_protocol",
    42,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(GroupCfgSt, has_client_bypass_protocol),
    offsetof(GroupCfgSt, client_bypass_protocol),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned group_cfg_st__field_indices_by_name[] = {
  12,   /* field[12] = cgroup */
  33,   /* field[33] = client_bypass_protocol */
  3,   /* field[3] = deny_roaming */
  6,   /* field[6] = dns */
  21,   /* field[21] = dpd */
  17,   /* field[17] = explicit_ipv4 */
  18,   /* field[18] = explicit_ipv6 */
  30,   /* field[30] = fw_ports */
  31,   /* field[31] = hostname */
  28,   /* field[28] = idle_timeout */
  0,   /* field[0] = interim_update_secs */
  8,   /* field[8] = ipv4_net */
  9,   /* field[9] = ipv4_netmask */
  10,   /* field[10] = ipv6_net */
  11,   /* field[11] = ipv6_prefix */
  20,   /* field[20] = ipv6_subnet_prefix */
  5,   /* field[5] = iroutes */
  23,   /* field[23] = keepalive */
  24,   /* field[24] = max_same_clients */
  22,   /* field[22] = mobile_dpd */
  29,   /* field[29] = mobile_idle_timeout */
  27,   /* field[27] = mtu */
  7,   /* field[7] = nbns */
  16,   /* field[16] = net_priority */
  19,   /* field[19] = no_routes */
  2,   /* field[2] = no_udp */
  26,   /* field[26] = restrict_user_to_routes */
  4,   /* field[4] = routes */
  14,   /* field[14] = rx_per_sec */
  1,   /* field[1] = session_timeout_secs */
  32,   /* field[32] = split_dns */
  25,   /* field[25] = tunnel_all_dns */
  15,   /* field[15] = tx_per_sec */
  13,   /* field[13] = xml_config_file */
};
static const ProtobufCIntRange group_cfg_st__number_ranges[3 + 1] =
{
  { 2, 0 },
  { 10, 2 },
  { 13, 4 },
  { 0, 34 }
};
const ProtobufCMessageDescriptor group_cfg_st__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "group_cfg_st",
  "GroupCfgSt",
  "GroupCfgSt",
  "",
  sizeof(GroupCfgSt),
  34,
  group_cfg_st__field_descriptors,
  group_cfg_st__field_indices_by_name,
  3,  group_cfg_st__number_ranges,
  (ProtobufCMessageInit) group_cfg_st__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor auth_cookie_reply_msg__field_descriptors[13] =
{
  {
    "reply",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, reply),
    &auth__rep__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_id",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(AuthCookieReplyMsg, has_session_id),
    offsetof(AuthCookieReplyMsg, session_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vname",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, vname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_name",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, user_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "group_name",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, group_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, ipv4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, ipv6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4_local",
    9,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, ipv4_local),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6_local",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, ipv6_local),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    11,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_start_time",
    12,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, session_start_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secmod_addr",
    13,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, secmod_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "config",
    20,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(AuthCookieReplyMsg, config),
    &group_cfg_st__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned auth_cookie_reply_msg__field_indices_by_name[] = {
  12,   /* field[12] = config */
  4,   /* field[4] = group_name */
  5,   /* field[5] = ipv4 */
  7,   /* field[7] = ipv4_local */
  6,   /* field[6] = ipv6 */
  8,   /* field[8] = ipv6_local */
  0,   /* field[0] = reply */
  11,   /* field[11] = secmod_addr */
  1,   /* field[1] = session_id */
  10,   /* field[10] = session_start_time */
  9,   /* field[9] = sid */
  3,   /* field[3] = user_name */
  2,   /* field[2] = vname */
};
static const ProtobufCIntRange auth_cookie_reply_msg__number_ranges[3 + 1] =
{
  { 1, 0 },
  { 3, 1 },
  { 20, 12 },
  { 0, 13 }
};
const ProtobufCMessageDescriptor auth_cookie_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "auth_cookie_reply_msg",
  "AuthCookieReplyMsg",
  "AuthCookieReplyMsg",
  "",
  sizeof(AuthCookieReplyMsg),
  13,
  auth_cookie_reply_msg__field_descriptors,
  auth_cookie_reply_msg__field_indices_by_name,
  3,  auth_cookie_reply_msg__number_ranges,
  (ProtobufCMessageInit) auth_cookie_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor session_resume_fetch_msg__field_descriptors[3] =
{
  {
    "session_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SessionResumeFetchMsg, session_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cli_addr",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SessionResumeFetchMsg, cli_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionResumeFetchMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned session_resume_fetch_msg__field_indices_by_name[] = {
  1,   /* field[1] = cli_addr */
  0,   /* field[0] = session_id */
  2,   /* field[2] = vhost */
};
static const ProtobufCIntRange session_resume_fetch_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor session_resume_fetch_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "session_resume_fetch_msg",
  "SessionResumeFetchMsg",
  "SessionResumeFetchMsg",
  "",
  sizeof(SessionResumeFetchMsg),
  3,
  session_resume_fetch_msg__field_descriptors,
  session_resume_fetch_msg__field_indices_by_name,
  1,  session_resume_fetch_msg__number_ranges,
  (ProtobufCMessageInit) session_resume_fetch_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor session_resume_store_req_msg__field_descriptors[4] =
{
  {
    "session_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SessionResumeStoreReqMsg, session_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_data",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SessionResumeStoreReqMsg, session_data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cli_addr",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SessionResumeStoreReqMsg, cli_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionResumeStoreReqMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned session_resume_store_req_msg__field_indices_by_name[] = {
  2,   /* field[2] = cli_addr */
  1,   /* field[1] = session_data */
  0,   /* field[0] = session_id */
  3,   /* field[3] = vhost */
};
static const ProtobufCIntRange session_resume_store_req_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor session_resume_store_req_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "session_resume_store_req_msg",
  "SessionResumeStoreReqMsg",
  "SessionResumeStoreReqMsg",
  "",
  sizeof(SessionResumeStoreReqMsg),
  4,
  session_resume_store_req_msg__field_descriptors,
  session_resume_store_req_msg__field_indices_by_name,
  1,  session_resume_store_req_msg__number_ranges,
  (ProtobufCMessageInit) session_resume_store_req_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue session_resume_reply_msg__resume__rep__enum_values_by_number[2] =
{
  { "OK", "SESSION_RESUME_REPLY_MSG__RESUME__REP__OK", 1 },
  { "FAILED", "SESSION_RESUME_REPLY_MSG__RESUME__REP__FAILED", 2 },
};
static const ProtobufCIntRange session_resume_reply_msg__resume__rep__value_ranges[] = {
{1, 0},{0, 2}
};
static const ProtobufCEnumValueIndex session_resume_reply_msg__resume__rep__enum_values_by_name[2] =
{
  { "FAILED", 1 },
  { "OK", 0 },
};
const ProtobufCEnumDescriptor session_resume_reply_msg__resume__rep__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "session_resume_reply_msg.RESUME_REP",
  "RESUME_REP",
  "SessionResumeReplyMsg__RESUMEREP",
  "",
  2,
  session_resume_reply_msg__resume__rep__enum_values_by_number,
  2,
  session_resume_reply_msg__resume__rep__enum_values_by_name,
  1,
  session_resume_reply_msg__resume__rep__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor session_resume_reply_msg__field_descriptors[2] =
{
  {
    "reply",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(SessionResumeReplyMsg, reply),
    &session_resume_reply_msg__resume__rep__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_data",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(SessionResumeReplyMsg, has_session_data),
    offsetof(SessionResumeReplyMsg, session_data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned session_resume_reply_msg__field_indices_by_name[] = {
  0,   /* field[0] = reply */
  1,   /* field[1] = session_data */
};
static const ProtobufCIntRange session_resume_reply_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor session_resume_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "session_resume_reply_msg",
  "SessionResumeReplyMsg",
  "SessionResumeReplyMsg",
  "",
  sizeof(SessionResumeReplyMsg),
  2,
  session_resume_reply_msg__field_descriptors,
  session_resume_reply_msg__field_indices_by_name,
  1,  session_resume_reply_msg__number_ranges,
  (ProtobufCMessageInit) session_resume_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor tun_mtu_msg__field_descriptors[1] =
{
  {
    "mtu",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(TunMtuMsg, mtu),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned tun_mtu_msg__field_indices_by_name[] = {
  0,   /* field[0] = mtu */
};
static const ProtobufCIntRange tun_mtu_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor tun_mtu_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "tun_mtu_msg",
  "TunMtuMsg",
  "TunMtuMsg",
  "",
  sizeof(TunMtuMsg),
  1,
  tun_mtu_msg__field_descriptors,
  tun_mtu_msg__field_indices_by_name,
  1,  tun_mtu_msg__number_ranges,
  (ProtobufCMessageInit) tun_mtu_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor cli_stats_msg__field_descriptors[8] =
{
  {
    "bytes_in",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, bytes_in),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bytes_out",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, bytes_out),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(CliStatsMsg, has_sid),
    offsetof(CliStatsMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "uptime",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, uptime),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_ip",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, remote_ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, ipv4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CliStatsMsg, ipv6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "discon_reason",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(CliStatsMsg, has_discon_reason),
    offsetof(CliStatsMsg, discon_reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned cli_stats_msg__field_indices_by_name[] = {
  0,   /* field[0] = bytes_in */
  1,   /* field[1] = bytes_out */
  7,   /* field[7] = discon_reason */
  5,   /* field[5] = ipv4 */
  6,   /* field[6] = ipv6 */
  4,   /* field[4] = remote_ip */
  2,   /* field[2] = sid */
  3,   /* field[3] = uptime */
};
static const ProtobufCIntRange cli_stats_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 8 }
};
const ProtobufCMessageDescriptor cli_stats_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "cli_stats_msg",
  "CliStatsMsg",
  "CliStatsMsg",
  "",
  sizeof(CliStatsMsg),
  8,
  cli_stats_msg__field_descriptors,
  cli_stats_msg__field_indices_by_name,
  1,  cli_stats_msg__number_ranges,
  (ProtobufCMessageInit) cli_stats_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean udp_fd_msg__hello__default_value = 1;
static const ProtobufCFieldDescriptor udp_fd_msg__field_descriptors[2] =
{
  {
    "hello",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(UdpFdMsg, hello),
    NULL,
    &udp_fd_msg__hello__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(UdpFdMsg, data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned udp_fd_msg__field_indices_by_name[] = {
  1,   /* field[1] = data */
  0,   /* field[0] = hello */
};
static const ProtobufCIntRange udp_fd_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor udp_fd_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "udp_fd_msg",
  "UdpFdMsg",
  "UdpFdMsg",
  "",
  sizeof(UdpFdMsg),
  2,
  udp_fd_msg__field_descriptors,
  udp_fd_msg__field_indices_by_name,
  1,  udp_fd_msg__number_ranges,
  (ProtobufCMessageInit) udp_fd_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor snapshot_entry_msg__field_descriptors[2] =
{
  {
    "file_descriptor",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SnapshotEntryMsg, file_descriptor),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "file_name",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SnapshotEntryMsg, file_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned snapshot_entry_msg__field_indices_by_name[] = {
  0,   /* field[0] = file_descriptor */
  1,   /* field[1] = file_name */
};
static const ProtobufCIntRange snapshot_entry_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor snapshot_entry_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "snapshot_entry_msg",
  "SnapshotEntryMsg",
  "SnapshotEntryMsg",
  "",
  sizeof(SnapshotEntryMsg),
  2,
  snapshot_entry_msg__field_descriptors,
  snapshot_entry_msg__field_indices_by_name,
  1,  snapshot_entry_msg__number_ranges,
  (ProtobufCMessageInit) snapshot_entry_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue worker_startup_msg__conn__type__enum_values_by_number[3] =
{
  { "TCP", "WORKER_STARTUP_MSG__CONN__TYPE__TCP", 0 },
  { "UDP", "WORKER_STARTUP_MSG__CONN__TYPE__UDP", 1 },
  { "UNIX", "WORKER_STARTUP_MSG__CONN__TYPE__UNIX", 2 },
};
static const ProtobufCIntRange worker_startup_msg__conn__type__value_ranges[] = {
{0, 0},{0, 3}
};
static const ProtobufCEnumValueIndex worker_startup_msg__conn__type__enum_values_by_name[3] =
{
  { "TCP", 0 },
  { "UDP", 1 },
  { "UNIX", 2 },
};
const ProtobufCEnumDescriptor worker_startup_msg__conn__type__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "worker_startup_msg.CONN_TYPE",
  "CONN_TYPE",
  "WorkerStartupMsg__CONNTYPE",
  "",
  3,
  worker_startup_msg__conn__type__enum_values_by_number,
  3,
  worker_startup_msg__conn__type__enum_values_by_name,
  1,
  worker_startup_msg__conn__type__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
static const ProtobufCFieldDescriptor worker_startup_msg__field_descriptors[14] =
{
  {
    "secmod_addr",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, secmod_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cmd_fd",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, cmd_fd),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "conn_fd",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, conn_fd),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "conn_type",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, conn_type),
    &worker_startup_msg__conn__type__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_ip_str",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, remote_ip_str),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "our_ip_str",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, our_ip_str),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_start_time",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, session_start_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_addr",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, remote_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "our_addr",
    9,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, our_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sec_auth_init_hmac",
    10,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(WorkerStartupMsg, sec_auth_init_hmac),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "snapshot_entries",
    11,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(WorkerStartupMsg, n_snapshot_entries),
    offsetof(WorkerStartupMsg, snapshot_entries),
    &snapshot_entry_msg__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "pam_auth_group_list",
    12,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(WorkerStartupMsg, n_pam_auth_group_list),
    offsetof(WorkerStartupMsg, pam_auth_group_list),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "gssapi_auth_group_list",
    13,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(WorkerStartupMsg, n_gssapi_auth_group_list),
    offsetof(WorkerStartupMsg, gssapi_auth_group_list),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "plain_auth_group_list",
    14,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(WorkerStartupMsg, n_plain_auth_group_list),
    offsetof(WorkerStartupMsg, plain_auth_group_list),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned worker_startup_msg__field_indices_by_name[] = {
  1,   /* field[1] = cmd_fd */
  2,   /* field[2] = conn_fd */
  3,   /* field[3] = conn_type */
  12,   /* field[12] = gssapi_auth_group_list */
  8,   /* field[8] = our_addr */
  5,   /* field[5] = our_ip_str */
  11,   /* field[11] = pam_auth_group_list */
  13,   /* field[13] = plain_auth_group_list */
  7,   /* field[7] = remote_addr */
  4,   /* field[4] = remote_ip_str */
  9,   /* field[9] = sec_auth_init_hmac */
  0,   /* field[0] = secmod_addr */
  6,   /* field[6] = session_start_time */
  10,   /* field[10] = snapshot_entries */
};
static const ProtobufCIntRange worker_startup_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 14 }
};
const ProtobufCMessageDescriptor worker_startup_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "worker_startup_msg",
  "WorkerStartupMsg",
  "WorkerStartupMsg",
  "",
  sizeof(WorkerStartupMsg),
  14,
  worker_startup_msg__field_descriptors,
  worker_startup_msg__field_indices_by_name,
  1,  worker_startup_msg__number_ranges,
  (ProtobufCMessageInit) worker_startup_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor session_info_msg__field_descriptors[6] =
{
  {
    "tls_ciphersuite",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionInfoMsg, tls_ciphersuite),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dtls_ciphersuite",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionInfoMsg, dtls_ciphersuite),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cstp_compr",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionInfoMsg, cstp_compr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dtls_compr",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SessionInfoMsg, dtls_compr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "our_addr",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(SessionInfoMsg, has_our_addr),
    offsetof(SessionInfoMsg, our_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_addr",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(SessionInfoMsg, has_remote_addr),
    offsetof(SessionInfoMsg, remote_addr),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned session_info_msg__field_indices_by_name[] = {
  2,   /* field[2] = cstp_compr */
  1,   /* field[1] = dtls_ciphersuite */
  3,   /* field[3] = dtls_compr */
  4,   /* field[4] = our_addr */
  5,   /* field[5] = remote_addr */
  0,   /* field[0] = tls_ciphersuite */
};
static const ProtobufCIntRange session_info_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor session_info_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "session_info_msg",
  "SessionInfoMsg",
  "SessionInfoMsg",
  "",
  sizeof(SessionInfoMsg),
  6,
  session_info_msg__field_descriptors,
  session_info_msg__field_indices_by_name,
  1,  session_info_msg__number_ranges,
  (ProtobufCMessageInit) session_info_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor ban_ip_msg__field_descriptors[4] =
{
  {
    "ip",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(BanIpMsg, ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "score",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(BanIpMsg, score),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(BanIpMsg, has_sid),
    offsetof(BanIpMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "discon_reason",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(BanIpMsg, has_discon_reason),
    offsetof(BanIpMsg, discon_reason),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned ban_ip_msg__field_indices_by_name[] = {
  3,   /* field[3] = discon_reason */
  0,   /* field[0] = ip */
  1,   /* field[1] = score */
  2,   /* field[2] = sid */
};
static const ProtobufCIntRange ban_ip_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor ban_ip_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ban_ip_msg",
  "BanIpMsg",
  "BanIpMsg",
  "",
  sizeof(BanIpMsg),
  4,
  ban_ip_msg__field_descriptors,
  ban_ip_msg__field_indices_by_name,
  1,  ban_ip_msg__number_ranges,
  (ProtobufCMessageInit) ban_ip_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor ban_ip_reply_msg__field_descriptors[2] =
{
  {
    "reply",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(BanIpReplyMsg, reply),
    &auth__rep__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    2,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(BanIpReplyMsg, has_sid),
    offsetof(BanIpReplyMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned ban_ip_reply_msg__field_indices_by_name[] = {
  0,   /* field[0] = reply */
  1,   /* field[1] = sid */
};
static const ProtobufCIntRange ban_ip_reply_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 2 }
};
const ProtobufCMessageDescriptor ban_ip_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "ban_ip_reply_msg",
  "BanIpReplyMsg",
  "BanIpReplyMsg",
  "",
  sizeof(BanIpReplyMsg),
  2,
  ban_ip_reply_msg__field_descriptors,
  ban_ip_reply_msg__field_indices_by_name,
  1,  ban_ip_reply_msg__number_ranges,
  (ProtobufCMessageInit) ban_ip_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor latency_stats_delta__field_descriptors[3] =
{
  {
    "median_delta",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(LatencyStatsDelta, median_delta),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "rms_delta",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(LatencyStatsDelta, rms_delta),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sample_count_delta",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(LatencyStatsDelta, sample_count_delta),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned latency_stats_delta__field_indices_by_name[] = {
  0,   /* field[0] = median_delta */
  1,   /* field[1] = rms_delta */
  2,   /* field[2] = sample_count_delta */
};
static const ProtobufCIntRange latency_stats_delta__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor latency_stats_delta__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "latency_stats_delta",
  "LatencyStatsDelta",
  "LatencyStatsDelta",
  "",
  sizeof(LatencyStatsDelta),
  3,
  latency_stats_delta__field_descriptors,
  latency_stats_delta__field_indices_by_name,
  1,  latency_stats_delta__number_ranges,
  (ProtobufCMessageInit) latency_stats_delta__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean sec_auth_init_msg__tls_auth_ok__default_value = 0;
static const uint32_t sec_auth_init_msg__auth_type__default_value = 0u;
static const ProtobufCFieldDescriptor sec_auth_init_msg__field_descriptors[15] =
{
  {
    "tls_auth_ok",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, tls_auth_ok),
    NULL,
    &sec_auth_init_msg__tls_auth_ok__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_name",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, user_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "group_name",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, group_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cert_user_name",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, cert_user_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "cert_group_names",
    6,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_STRING,
    offsetof(SecAuthInitMsg, n_cert_group_names),
    offsetof(SecAuthInitMsg, cert_group_names),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_ip",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, remote_ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "auth_type",
    9,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, auth_type),
    NULL,
    &sec_auth_init_msg__auth_type__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "our_ip",
    10,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, our_ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_agent",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, user_agent),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "device_platform",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, device_platform),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "device_type",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, device_type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_start_time",
    15,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, session_start_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "hmac",
    16,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, hmac),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "orig_remote_ip",
    17,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthInitMsg, orig_remote_ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned sec_auth_init_msg__field_indices_by_name[] = {
  6,   /* field[6] = auth_type */
  4,   /* field[4] = cert_group_names */
  3,   /* field[3] = cert_user_name */
  9,   /* field[9] = device_platform */
  10,   /* field[10] = device_type */
  2,   /* field[2] = group_name */
  13,   /* field[13] = hmac */
  14,   /* field[14] = orig_remote_ip */
  7,   /* field[7] = our_ip */
  5,   /* field[5] = remote_ip */
  12,   /* field[12] = session_start_time */
  0,   /* field[0] = tls_auth_ok */
  8,   /* field[8] = user_agent */
  1,   /* field[1] = user_name */
  11,   /* field[11] = vhost */
};
static const ProtobufCIntRange sec_auth_init_msg__number_ranges[2 + 1] =
{
  { 2, 0 },
  { 8, 5 },
  { 0, 15 }
};
const ProtobufCMessageDescriptor sec_auth_init_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "sec_auth_init_msg",
  "SecAuthInitMsg",
  "SecAuthInitMsg",
  "",
  sizeof(SecAuthInitMsg),
  15,
  sec_auth_init_msg__field_descriptors,
  sec_auth_init_msg__field_indices_by_name,
  2,  sec_auth_init_msg__number_ranges,
  (ProtobufCMessageInit) sec_auth_init_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor sec_auth_cont_msg__field_descriptors[3] =
{
  {
    "password",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthContMsg, password),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecAuthContMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ip",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthContMsg, ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned sec_auth_cont_msg__field_indices_by_name[] = {
  2,   /* field[2] = ip */
  0,   /* field[0] = password */
  1,   /* field[1] = sid */
};
static const ProtobufCIntRange sec_auth_cont_msg__number_ranges[1 + 1] =
{
  { 2, 0 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor sec_auth_cont_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "sec_auth_cont_msg",
  "SecAuthContMsg",
  "SecAuthContMsg",
  "",
  sizeof(SecAuthContMsg),
  3,
  sec_auth_cont_msg__field_descriptors,
  sec_auth_cont_msg__field_indices_by_name,
  1,  sec_auth_cont_msg__number_ranges,
  (ProtobufCMessageInit) sec_auth_cont_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor sec_auth_reply_msg__field_descriptors[6] =
{
  {
    "reply",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(SecAuthReplyMsg, reply),
    &auth__rep__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_name",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthReplyMsg, user_name),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "msg",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecAuthReplyMsg, msg),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "dtls_session_id",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(SecAuthReplyMsg, has_dtls_session_id),
    offsetof(SecAuthReplyMsg, dtls_session_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_BYTES,
    offsetof(SecAuthReplyMsg, has_sid),
    offsetof(SecAuthReplyMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "passwd_counter",
    8,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(SecAuthReplyMsg, has_passwd_counter),
    offsetof(SecAuthReplyMsg, passwd_counter),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned sec_auth_reply_msg__field_indices_by_name[] = {
  3,   /* field[3] = dtls_session_id */
  2,   /* field[2] = msg */
  5,   /* field[5] = passwd_counter */
  0,   /* field[0] = reply */
  4,   /* field[4] = sid */
  1,   /* field[1] = user_name */
};
static const ProtobufCIntRange sec_auth_reply_msg__number_ranges[3 + 1] =
{
  { 1, 0 },
  { 3, 1 },
  { 8, 5 },
  { 0, 6 }
};
const ProtobufCMessageDescriptor sec_auth_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "sec_auth_reply_msg",
  "SecAuthReplyMsg",
  "SecAuthReplyMsg",
  "",
  sizeof(SecAuthReplyMsg),
  6,
  sec_auth_reply_msg__field_descriptors,
  sec_auth_reply_msg__field_indices_by_name,
  3,  sec_auth_reply_msg__number_ranges,
  (ProtobufCMessageInit) sec_auth_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor sec_op_msg__field_descriptors[4] =
{
  {
    "key_idx",
    1,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(SecOpMsg, has_key_idx),
    offsetof(SecOpMsg, key_idx),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "data",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecOpMsg, data),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sig",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecOpMsg, sig),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecOpMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned sec_op_msg__field_indices_by_name[] = {
  1,   /* field[1] = data */
  0,   /* field[0] = key_idx */
  2,   /* field[2] = sig */
  3,   /* field[3] = vhost */
};
static const ProtobufCIntRange sec_op_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor sec_op_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "sec_op_msg",
  "SecOpMsg",
  "SecOpMsg",
  "",
  sizeof(SecOpMsg),
  4,
  sec_op_msg__field_descriptors,
  sec_op_msg__field_indices_by_name,
  1,  sec_op_msg__number_ranges,
  (ProtobufCMessageInit) sec_op_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor sec_get_pk_msg__field_descriptors[4] =
{
  {
    "key_idx",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecGetPkMsg, key_idx),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "pk",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecGetPkMsg, pk),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecGetPkMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bits",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(SecGetPkMsg, has_bits),
    offsetof(SecGetPkMsg, bits),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned sec_get_pk_msg__field_indices_by_name[] = {
  3,   /* field[3] = bits */
  0,   /* field[0] = key_idx */
  1,   /* field[1] = pk */
  2,   /* field[2] = vhost */
};
static const ProtobufCIntRange sec_get_pk_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 4 }
};
const ProtobufCMessageDescriptor sec_get_pk_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "sec_get_pk_msg",
  "SecGetPkMsg",
  "SecGetPkMsg",
  "",
  sizeof(SecGetPkMsg),
  4,
  sec_get_pk_msg__field_descriptors,
  sec_get_pk_msg__field_indices_by_name,
  1,  sec_get_pk_msg__number_ranges,
  (ProtobufCMessageInit) sec_get_pk_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor secm_session_open_msg__field_descriptors[3] =
{
  {
    "sid",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecmSessionOpenMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionOpenMsg, ipv4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionOpenMsg, ipv6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned secm_session_open_msg__field_indices_by_name[] = {
  1,   /* field[1] = ipv4 */
  2,   /* field[2] = ipv6 */
  0,   /* field[0] = sid */
};
static const ProtobufCIntRange secm_session_open_msg__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 6, 1 },
  { 0, 3 }
};
const ProtobufCMessageDescriptor secm_session_open_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "secm_session_open_msg",
  "SecmSessionOpenMsg",
  "SecmSessionOpenMsg",
  "",
  sizeof(SecmSessionOpenMsg),
  3,
  secm_session_open_msg__field_descriptors,
  secm_session_open_msg__field_indices_by_name,
  2,  secm_session_open_msg__number_ranges,
  (ProtobufCMessageInit) secm_session_open_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const protobuf_c_boolean secm_session_close_msg__server_disconnected__default_value = 0;
static const ProtobufCFieldDescriptor secm_session_close_msg__field_descriptors[7] =
{
  {
    "sid",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecmSessionCloseMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "uptime",
    3,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT32,
    offsetof(SecmSessionCloseMsg, has_uptime),
    offsetof(SecmSessionCloseMsg, uptime),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bytes_in",
    4,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(SecmSessionCloseMsg, has_bytes_in),
    offsetof(SecmSessionCloseMsg, bytes_in),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "bytes_out",
    5,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_UINT64,
    offsetof(SecmSessionCloseMsg, has_bytes_out),
    offsetof(SecmSessionCloseMsg, bytes_out),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionCloseMsg, ipv4),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv6",
    7,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionCloseMsg, ipv6),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "server_disconnected",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(SecmSessionCloseMsg, server_disconnected),
    NULL,
    &secm_session_close_msg__server_disconnected__default_value,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned secm_session_close_msg__field_indices_by_name[] = {
  2,   /* field[2] = bytes_in */
  3,   /* field[3] = bytes_out */
  4,   /* field[4] = ipv4 */
  5,   /* field[5] = ipv6 */
  6,   /* field[6] = server_disconnected */
  0,   /* field[0] = sid */
  1,   /* field[1] = uptime */
};
static const ProtobufCIntRange secm_session_close_msg__number_ranges[2 + 1] =
{
  { 1, 0 },
  { 3, 1 },
  { 0, 7 }
};
const ProtobufCMessageDescriptor secm_session_close_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "secm_session_close_msg",
  "SecmSessionCloseMsg",
  "SecmSessionCloseMsg",
  "",
  sizeof(SecmSessionCloseMsg),
  7,
  secm_session_close_msg__field_descriptors,
  secm_session_close_msg__field_indices_by_name,
  2,  secm_session_close_msg__number_ranges,
  (ProtobufCMessageInit) secm_session_close_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor secm_stats_msg__field_descriptors[5] =
{
  {
    "secmod_client_entries",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecmStatsMsg, secmod_client_entries),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secmod_tlsdb_entries",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecmStatsMsg, secmod_tlsdb_entries),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secmod_auth_failures",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(SecmStatsMsg, secmod_auth_failures),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secmod_avg_auth_time",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecmStatsMsg, secmod_avg_auth_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "secmod_max_auth_time",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecmStatsMsg, secmod_max_auth_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned secm_stats_msg__field_indices_by_name[] = {
  2,   /* field[2] = secmod_auth_failures */
  3,   /* field[3] = secmod_avg_auth_time */
  0,   /* field[0] = secmod_client_entries */
  4,   /* field[4] = secmod_max_auth_time */
  1,   /* field[1] = secmod_tlsdb_entries */
};
static const ProtobufCIntRange secm_stats_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 5 }
};
const ProtobufCMessageDescriptor secm_stats_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "secm_stats_msg",
  "SecmStatsMsg",
  "SecmStatsMsg",
  "",
  sizeof(SecmStatsMsg),
  5,
  secm_stats_msg__field_descriptors,
  secm_stats_msg__field_indices_by_name,
  1,  secm_stats_msg__number_ranges,
  (ProtobufCMessageInit) secm_stats_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor secm_session_reply_msg__field_descriptors[13] =
{
  {
    "reply",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_ENUM,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, reply),
    &auth__rep__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "config",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_MESSAGE,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, config),
    &group_cfg_st__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "username",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, username),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "groupname",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, groupname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ip",
    6,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "ipv4_seed",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, ipv4_seed),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "sid",
    9,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, sid),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tls_auth_ok",
    10,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, tls_auth_ok),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    11,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_agent",
    12,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, user_agent),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "device_platform",
    13,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, device_platform),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "device_type",
    14,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, device_type),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_start_time",
    15,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(SecmSessionReplyMsg, session_start_time),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned secm_session_reply_msg__field_indices_by_name[] = {
  1,   /* field[1] = config */
  10,   /* field[10] = device_platform */
  11,   /* field[11] = device_type */
  3,   /* field[3] = groupname */
  4,   /* field[4] = ip */
  5,   /* field[5] = ipv4_seed */
  0,   /* field[0] = reply */
  12,   /* field[12] = session_start_time */
  6,   /* field[6] = sid */
  7,   /* field[7] = tls_auth_ok */
  9,   /* field[9] = user_agent */
  2,   /* field[2] = username */
  8,   /* field[8] = vhost */
};
static const ProtobufCIntRange secm_session_reply_msg__number_ranges[3 + 1] =
{
  { 1, 0 },
  { 6, 4 },
  { 8, 5 },
  { 0, 13 }
};
const ProtobufCMessageDescriptor secm_session_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "secm_session_reply_msg",
  "SecmSessionReplyMsg",
  "SecmSessionReplyMsg",
  "",
  sizeof(SecmSessionReplyMsg),
  13,
  secm_session_reply_msg__field_descriptors,
  secm_session_reply_msg__field_indices_by_name,
  3,  secm_session_reply_msg__number_ranges,
  (ProtobufCMessageInit) secm_session_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor cookie_int_msg__field_descriptors[12] =
{
  {
    "safe_id",
    1,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BYTES,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, safe_id),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "session_is_open",
    2,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, session_is_open),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "tls_auth_ok",
    3,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, tls_auth_ok),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "created",
    4,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT64,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, created),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "username",
    5,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, username),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "groupname",
    6,
    PROTOBUF_C_LABEL_OPTIONAL,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, groupname),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "user_agent",
    7,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, user_agent),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "remote_ip",
    8,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, remote_ip),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "expires",
    9,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, expires),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "status",
    10,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_UINT32,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, status),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "in_use",
    11,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_BOOL,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, in_use),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
  {
    "vhost",
    12,
    PROTOBUF_C_LABEL_REQUIRED,
    PROTOBUF_C_TYPE_STRING,
    0,   /* quantifier_offset */
    offsetof(CookieIntMsg, vhost),
    NULL,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned cookie_int_msg__field_indices_by_name[] = {
  3,   /* field[3] = created */
  8,   /* field[8] = expires */
  5,   /* field[5] = groupname */
  10,   /* field[10] = in_use */
  7,   /* field[7] = remote_ip */
  0,   /* field[0] = safe_id */
  1,   /* field[1] = session_is_open */
  9,   /* field[9] = status */
  2,   /* field[2] = tls_auth_ok */
  6,   /* field[6] = user_agent */
  4,   /* field[4] = username */
  11,   /* field[11] = vhost */
};
static const ProtobufCIntRange cookie_int_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 12 }
};
const ProtobufCMessageDescriptor cookie_int_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "cookie_int_msg",
  "CookieIntMsg",
  "CookieIntMsg",
  "",
  sizeof(CookieIntMsg),
  12,
  cookie_int_msg__field_descriptors,
  cookie_int_msg__field_indices_by_name,
  1,  cookie_int_msg__number_ranges,
  (ProtobufCMessageInit) cookie_int_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCFieldDescriptor secm_list_cookies_reply_msg__field_descriptors[1] =
{
  {
    "cookies",
    1,
    PROTOBUF_C_LABEL_REPEATED,
    PROTOBUF_C_TYPE_MESSAGE,
    offsetof(SecmListCookiesReplyMsg, n_cookies),
    offsetof(SecmListCookiesReplyMsg, cookies),
    &cookie_int_msg__descriptor,
    NULL,
    0,             /* flags */
    0,NULL,NULL    /* reserved1,reserved2, etc */
  },
};
static const unsigned secm_list_cookies_reply_msg__field_indices_by_name[] = {
  0,   /* field[0] = cookies */
};
static const ProtobufCIntRange secm_list_cookies_reply_msg__number_ranges[1 + 1] =
{
  { 1, 0 },
  { 0, 1 }
};
const ProtobufCMessageDescriptor secm_list_cookies_reply_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "secm_list_cookies_reply_msg",
  "SecmListCookiesReplyMsg",
  "SecmListCookiesReplyMsg",
  "",
  sizeof(SecmListCookiesReplyMsg),
  1,
  secm_list_cookies_reply_msg__field_descriptors,
  secm_list_cookies_reply_msg__field_indices_by_name,
  1,  secm_list_cookies_reply_msg__number_ranges,
  (ProtobufCMessageInit) secm_list_cookies_reply_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
#define snapshot_state_msg__field_descriptors NULL
#define snapshot_state_msg__field_indices_by_name NULL
#define snapshot_state_msg__number_ranges NULL
const ProtobufCMessageDescriptor snapshot_state_msg__descriptor =
{
  PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
  "snapshot_state_msg",
  "SnapshotStateMsg",
  "SnapshotStateMsg",
  "",
  sizeof(SnapshotStateMsg),
  0,
  snapshot_state_msg__field_descriptors,
  snapshot_state_msg__field_indices_by_name,
  0,  snapshot_state_msg__number_ranges,
  (ProtobufCMessageInit) snapshot_state_msg__init,
  NULL,NULL,NULL    /* reserved[123] */
};
static const ProtobufCEnumValue auth__rep__enum_values_by_number[3] =
{
  { "OK", "AUTH__REP__OK", 1 },
  { "MSG", "AUTH__REP__MSG", 2 },
  { "FAILED", "AUTH__REP__FAILED", 3 },
};
static const ProtobufCIntRange auth__rep__value_ranges[] = {
{1, 0},{0, 3}
};
static const ProtobufCEnumValueIndex auth__rep__enum_values_by_name[3] =
{
  { "FAILED", 2 },
  { "MSG", 1 },
  { "OK", 0 },
};
const ProtobufCEnumDescriptor auth__rep__descriptor =
{
  PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
  "AUTH_REP",
  "AUTH_REP",
  "AUTHREP",
  "",
  3,
  auth__rep__enum_values_by_number,
  3,
  auth__rep__enum_values_by_name,
  1,
  auth__rep__value_ranges,
  NULL,NULL,NULL,NULL   /* reserved[1234] */
};
