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

#ifndef PROTOBUF_C_ipc_2eproto__INCLUDED
#define PROTOBUF_C_ipc_2eproto__INCLUDED

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

PROTOBUF_C__BEGIN_DECLS

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


typedef struct AuthCookieRequestMsg AuthCookieRequestMsg;
typedef struct FwPortSt FwPortSt;
typedef struct GroupCfgSt GroupCfgSt;
typedef struct AuthCookieReplyMsg AuthCookieReplyMsg;
typedef struct SessionResumeFetchMsg SessionResumeFetchMsg;
typedef struct SessionResumeStoreReqMsg SessionResumeStoreReqMsg;
typedef struct SessionResumeReplyMsg SessionResumeReplyMsg;
typedef struct TunMtuMsg TunMtuMsg;
typedef struct CliStatsMsg CliStatsMsg;
typedef struct UdpFdMsg UdpFdMsg;
typedef struct SnapshotEntryMsg SnapshotEntryMsg;
typedef struct WorkerStartupMsg WorkerStartupMsg;
typedef struct SessionInfoMsg SessionInfoMsg;
typedef struct BanIpMsg BanIpMsg;
typedef struct BanIpReplyMsg BanIpReplyMsg;
typedef struct LatencyStatsDelta LatencyStatsDelta;
typedef struct SecAuthInitMsg SecAuthInitMsg;
typedef struct SecAuthContMsg SecAuthContMsg;
typedef struct SecAuthReplyMsg SecAuthReplyMsg;
typedef struct SecOpMsg SecOpMsg;
typedef struct SecGetPkMsg SecGetPkMsg;
typedef struct SecmSessionOpenMsg SecmSessionOpenMsg;
typedef struct SecmSessionCloseMsg SecmSessionCloseMsg;
typedef struct SecmStatsMsg SecmStatsMsg;
typedef struct SecmSessionReplyMsg SecmSessionReplyMsg;
typedef struct CookieIntMsg CookieIntMsg;
typedef struct SecmListCookiesReplyMsg SecmListCookiesReplyMsg;
typedef struct SecmTerminateUserSessionsMsg SecmTerminateUserSessionsMsg;
typedef struct SecmTerminateSessionMsg SecmTerminateSessionMsg;
typedef struct SecmTerminateSessionReplyMsg SecmTerminateSessionReplyMsg;
typedef struct SnapshotStateMsg SnapshotStateMsg;


/* --- enums --- */

typedef enum _SessionResumeReplyMsg__RESUMEREP {
  SESSION_RESUME_REPLY_MSG__RESUME__REP__OK = 1,
  SESSION_RESUME_REPLY_MSG__RESUME__REP__FAILED = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SESSION_RESUME_REPLY_MSG__RESUME__REP)
} SessionResumeReplyMsg__RESUMEREP;
typedef enum _WorkerStartupMsg__CONNTYPE {
  WORKER_STARTUP_MSG__CONN__TYPE__TCP = 0,
  WORKER_STARTUP_MSG__CONN__TYPE__UDP = 1,
  WORKER_STARTUP_MSG__CONN__TYPE__UNIX = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(WORKER_STARTUP_MSG__CONN__TYPE)
} WorkerStartupMsg__CONNTYPE;
typedef enum _AUTHREP {
  AUTH__REP__OK = 1,
  AUTH__REP__MSG = 2,
  AUTH__REP__FAILED = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(AUTH__REP)
} AUTHREP;

/* --- messages --- */

/*
 * AUTH_COOKIE_REQ 
 */
struct  AuthCookieRequestMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData cookie;
  char *hostname;
};
#define AUTH_COOKIE_REQUEST_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&auth_cookie_request_msg__descriptor) \
    , {0,NULL}, NULL }


struct  FwPortSt
{
  ProtobufCMessage base;
  uint32_t port;
  /*
   * fw_proto_t 
   */
  uint32_t proto;
  /*
   * negative rule, i.e., if non zero reject this port 
   */
  uint32_t negate;
};
#define FW_PORT_ST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&fw_port_st__descriptor) \
    , 0, 0, 0 }


/*
 * This is a structure for per-user/group supplemental configuration.
 */
struct  GroupCfgSt
{
  ProtobufCMessage base;
  /*
   * sup - config, to add values, ensure we
   * apply a reasonable default in apply_default_config() 
   */
  protobuf_c_boolean has_interim_update_secs;
  uint32_t interim_update_secs;
  protobuf_c_boolean has_session_timeout_secs;
  uint32_t session_timeout_secs;
  protobuf_c_boolean has_no_udp;
  protobuf_c_boolean no_udp;
  protobuf_c_boolean has_deny_roaming;
  protobuf_c_boolean deny_roaming;
  size_t n_routes;
  char **routes;
  size_t n_iroutes;
  char **iroutes;
  size_t n_dns;
  char **dns;
  size_t n_nbns;
  char **nbns;
  char *ipv4_net;
  char *ipv4_netmask;
  char *ipv6_net;
  protobuf_c_boolean has_ipv6_prefix;
  uint32_t ipv6_prefix;
  char *cgroup;
  char *xml_config_file;
  protobuf_c_boolean has_rx_per_sec;
  uint32_t rx_per_sec;
  protobuf_c_boolean has_tx_per_sec;
  uint32_t tx_per_sec;
  protobuf_c_boolean has_net_priority;
  uint32_t net_priority;
  char *explicit_ipv4;
  char *explicit_ipv6;
  size_t n_no_routes;
  char **no_routes;
  protobuf_c_boolean has_ipv6_subnet_prefix;
  uint32_t ipv6_subnet_prefix;
  protobuf_c_boolean has_dpd;
  uint32_t dpd;
  protobuf_c_boolean has_mobile_dpd;
  uint32_t mobile_dpd;
  protobuf_c_boolean has_keepalive;
  uint32_t keepalive;
  protobuf_c_boolean has_max_same_clients;
  uint32_t max_same_clients;
  protobuf_c_boolean has_tunnel_all_dns;
  uint32_t tunnel_all_dns;
  protobuf_c_boolean has_restrict_user_to_routes;
  protobuf_c_boolean restrict_user_to_routes;
  protobuf_c_boolean has_mtu;
  uint32_t mtu;
  protobuf_c_boolean has_idle_timeout;
  uint32_t idle_timeout;
  protobuf_c_boolean has_mobile_idle_timeout;
  uint32_t mobile_idle_timeout;
  size_t n_fw_ports;
  FwPortSt **fw_ports;
  char *hostname;
  size_t n_split_dns;
  char **split_dns;
  protobuf_c_boolean has_client_bypass_protocol;
  uint32_t client_bypass_protocol;
};
#define GROUP_CFG_ST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&group_cfg_st__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, 0,NULL, 0,NULL, 0,NULL, 0,NULL, NULL, NULL, NULL, 0, 0, NULL, NULL, 0, 0, 0, 0, 0, 0, NULL, NULL, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,NULL, NULL, 0,NULL, 0, 0 }


/*
 * AUTH_COOKIE_REP 
 */
struct  AuthCookieReplyMsg
{
  ProtobufCMessage base;
  AUTHREP reply;
  /*
   * dtls 
   */
  protobuf_c_boolean has_session_id;
  ProtobufCBinaryData session_id;
  char *vname;
  char *user_name;
  char *group_name;
  /*
   * the ips of the tun device 
   */
  char *ipv4;
  char *ipv6;
  char *ipv4_local;
  char *ipv6_local;
  ProtobufCBinaryData sid;
  int64_t session_start_time;
  ProtobufCBinaryData secmod_addr;
  /*
   * additional config 
   */
  GroupCfgSt *config;
};
#define AUTH_COOKIE_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&auth_cookie_reply_msg__descriptor) \
    , AUTH__REP__OK, 0, {0,NULL}, NULL, NULL, NULL, NULL, NULL, NULL, NULL, {0,NULL}, 0, {0,NULL}, NULL }


/*
 * RESUME_FETCH_REQ + RESUME_DELETE_REQ 
 */
struct  SessionResumeFetchMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData session_id;
  /*
   * this is of type sockaddr_storage,
   * and contains the address of the client.
   */
  ProtobufCBinaryData cli_addr;
  char *vhost;
};
#define SESSION_RESUME_FETCH_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&session_resume_fetch_msg__descriptor) \
    , {0,NULL}, {0,NULL}, NULL }


/*
 * RESUME_STORE_REQ 
 */
struct  SessionResumeStoreReqMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData session_id;
  ProtobufCBinaryData session_data;
  /*
   * this is of type sockaddr_storage,
   * and contains the address of the client.
   */
  ProtobufCBinaryData cli_addr;
  char *vhost;
};
#define SESSION_RESUME_STORE_REQ_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&session_resume_store_req_msg__descriptor) \
    , {0,NULL}, {0,NULL}, {0,NULL}, NULL }


/*
 * RESUME_FETCH_REP 
 */
struct  SessionResumeReplyMsg
{
  ProtobufCMessage base;
  SessionResumeReplyMsg__RESUMEREP reply;
  protobuf_c_boolean has_session_data;
  ProtobufCBinaryData session_data;
};
#define SESSION_RESUME_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&session_resume_reply_msg__descriptor) \
    , SESSION_RESUME_REPLY_MSG__RESUME__REP__OK, 0, {0,NULL} }


/*
 * TUN_MTU 
 */
struct  TunMtuMsg
{
  ProtobufCMessage base;
  uint32_t mtu;
};
#define TUN_MTU_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&tun_mtu_msg__descriptor) \
    , 0 }


/*
 * SECM_CLI_STATS 
 */
struct  CliStatsMsg
{
  ProtobufCMessage base;
  uint64_t bytes_in;
  uint64_t bytes_out;
  protobuf_c_boolean has_sid;
  ProtobufCBinaryData sid;
  int64_t uptime;
  char *remote_ip;
  char *ipv4;
  char *ipv6;
  protobuf_c_boolean has_discon_reason;
  uint32_t discon_reason;
};
#define CLI_STATS_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&cli_stats_msg__descriptor) \
    , 0, 0, 0, {0,NULL}, 0, NULL, NULL, NULL, 0, 0 }


/*
 * UDP_FD 
 */
struct  UdpFdMsg
{
  ProtobufCMessage base;
  /*
   * is that a client hello? 
   */
  protobuf_c_boolean hello;
  /*
   * the first packet in the fd 
   */
  ProtobufCBinaryData data;
};
#define UDP_FD_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&udp_fd_msg__descriptor) \
    , 1, {0,NULL} }


struct  SnapshotEntryMsg
{
  ProtobufCMessage base;
  uint32_t file_descriptor;
  char *file_name;
};
#define SNAPSHOT_ENTRY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&snapshot_entry_msg__descriptor) \
    , 0, NULL }


/*
 * WORKER_STARTUP 
 */
struct  WorkerStartupMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData secmod_addr;
  uint32_t cmd_fd;
  uint32_t conn_fd;
  WorkerStartupMsg__CONNTYPE conn_type;
  char *remote_ip_str;
  char *our_ip_str;
  int64_t session_start_time;
  ProtobufCBinaryData remote_addr;
  ProtobufCBinaryData our_addr;
  ProtobufCBinaryData sec_auth_init_hmac;
  size_t n_snapshot_entries;
  SnapshotEntryMsg **snapshot_entries;
  size_t n_pam_auth_group_list;
  char **pam_auth_group_list;
  size_t n_gssapi_auth_group_list;
  char **gssapi_auth_group_list;
  size_t n_plain_auth_group_list;
  char **plain_auth_group_list;
};
#define WORKER_STARTUP_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&worker_startup_msg__descriptor) \
    , {0,NULL}, 0, 0, WORKER_STARTUP_MSG__CONN__TYPE__TCP, NULL, NULL, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0,NULL, 0,NULL, 0,NULL, 0,NULL }


/*
 * SESSION_INFO 
 */
struct  SessionInfoMsg
{
  ProtobufCMessage base;
  char *tls_ciphersuite;
  char *dtls_ciphersuite;
  char *cstp_compr;
  char *dtls_compr;
  /*
   * these two are of type sockaddr_storage,
   * and contain the addresses we got from proxy
   * protocol (if any).
   */
  protobuf_c_boolean has_our_addr;
  ProtobufCBinaryData our_addr;
  protobuf_c_boolean has_remote_addr;
  ProtobufCBinaryData remote_addr;
};
#define SESSION_INFO_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&session_info_msg__descriptor) \
    , NULL, NULL, NULL, NULL, 0, {0,NULL}, 0, {0,NULL} }


/*
 * WORKER_BAN_IP: sent from worker to main 
 */
struct  BanIpMsg
{
  ProtobufCMessage base;
  char *ip;
  uint32_t score;
  /*
   * sec-mod sends it 
   */
  protobuf_c_boolean has_sid;
  ProtobufCBinaryData sid;
  protobuf_c_boolean has_discon_reason;
  uint32_t discon_reason;
};
#define BAN_IP_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ban_ip_msg__descriptor) \
    , NULL, 0, 0, {0,NULL}, 0, 0 }


struct  BanIpReplyMsg
{
  ProtobufCMessage base;
  /*
   * whether to disconnect the user 
   */
  AUTHREP reply;
  /*
   * sec-mod needs it 
   */
  protobuf_c_boolean has_sid;
  ProtobufCBinaryData sid;
};
#define BAN_IP_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ban_ip_reply_msg__descriptor) \
    , AUTH__REP__OK, 0, {0,NULL} }


/*
 * WORKER_LATENCY_STATS_DELTA: sent from worker to main 
 */
struct  LatencyStatsDelta
{
  ProtobufCMessage base;
  uint64_t median_delta;
  uint64_t rms_delta;
  uint64_t sample_count_delta;
};
#define LATENCY_STATS_DELTA__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&latency_stats_delta__descriptor) \
    , 0, 0, 0 }


/*
 * SEC_AUTH_INIT 
 */
struct  SecAuthInitMsg
{
  ProtobufCMessage base;
  protobuf_c_boolean tls_auth_ok;
  char *user_name;
  /*
   * selected group name 
   */
  char *group_name;
  char *cert_user_name;
  size_t n_cert_group_names;
  char **cert_group_names;
  char *remote_ip;
  uint32_t auth_type;
  char *our_ip;
  char *user_agent;
  char *device_platform;
  char *device_type;
  char *vhost;
  int64_t session_start_time;
  ProtobufCBinaryData hmac;
  /*
   * if proxy proto is in use this is
   *the original IP that initiated the session 
   */
  char *orig_remote_ip;
};
#define SEC_AUTH_INIT_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&sec_auth_init_msg__descriptor) \
    , 0, NULL, NULL, NULL, 0,NULL, NULL, 0u, NULL, NULL, NULL, NULL, NULL, 0, {0,NULL}, NULL }


/*
 * SEC_AUTH_CONT 
 */
struct  SecAuthContMsg
{
  ProtobufCMessage base;
  char *password;
  ProtobufCBinaryData sid;
  char *ip;
};
#define SEC_AUTH_CONT_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&sec_auth_cont_msg__descriptor) \
    , NULL, {0,NULL}, NULL }


/*
 * SEC_AUTH_REP 
 */
struct  SecAuthReplyMsg
{
  ProtobufCMessage base;
  AUTHREP reply;
  char *user_name;
  /*
   * message to display to user 
   */
  char *msg;
  protobuf_c_boolean has_dtls_session_id;
  ProtobufCBinaryData dtls_session_id;
  /*
   * cookie 
   */
  protobuf_c_boolean has_sid;
  ProtobufCBinaryData sid;
  /*
   * if that's a password prompt indicates the number of password asked 
   */
  protobuf_c_boolean has_passwd_counter;
  uint32_t passwd_counter;
};
#define SEC_AUTH_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&sec_auth_reply_msg__descriptor) \
    , AUTH__REP__OK, NULL, NULL, 0, {0,NULL}, 0, {0,NULL}, 0, 0 }


/*
 * SEC_SIGN/DECRYPT 
 */
struct  SecOpMsg
{
  ProtobufCMessage base;
  protobuf_c_boolean has_key_idx;
  uint32_t key_idx;
  ProtobufCBinaryData data;
  uint32_t sig;
  char *vhost;
};
#define SEC_OP_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&sec_op_msg__descriptor) \
    , 0, 0, {0,NULL}, 0, NULL }


struct  SecGetPkMsg
{
  ProtobufCMessage base;
  uint32_t key_idx;
  uint32_t pk;
  char *vhost;
  protobuf_c_boolean has_bits;
  uint32_t bits;
};
#define SEC_GET_PK_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&sec_get_pk_msg__descriptor) \
    , 0, 0, NULL, 0, 0 }


/*
 * SECM_SESSION_OPEN 
 */
struct  SecmSessionOpenMsg
{
  ProtobufCMessage base;
  /*
   * cookie 
   */
  ProtobufCBinaryData sid;
  char *ipv4;
  char *ipv6;
};
#define SECM_SESSION_OPEN_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_session_open_msg__descriptor) \
    , {0,NULL}, NULL, NULL }


/*
 * SECM_SESSION_CLOSE 
 */
struct  SecmSessionCloseMsg
{
  ProtobufCMessage base;
  /*
   * cookie 
   */
  ProtobufCBinaryData sid;
  protobuf_c_boolean has_uptime;
  int64_t uptime;
  protobuf_c_boolean has_bytes_in;
  uint64_t bytes_in;
  protobuf_c_boolean has_bytes_out;
  uint64_t bytes_out;
  char *ipv4;
  char *ipv6;
  protobuf_c_boolean server_disconnected;
};
#define SECM_SESSION_CLOSE_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_session_close_msg__descriptor) \
    , {0,NULL}, 0, 0, 0, 0, 0, 0, NULL, NULL, 0 }


/*
 * SECM_STATS 
 */
struct  SecmStatsMsg
{
  ProtobufCMessage base;
  uint32_t secmod_client_entries;
  uint32_t secmod_tlsdb_entries;
  /*
   * failures since last update 
   */
  uint64_t secmod_auth_failures;
  /*
   * average auth time in seconds 
   */
  uint32_t secmod_avg_auth_time;
  /*
   * max auth time in seconds 
   */
  uint32_t secmod_max_auth_time;
};
#define SECM_STATS_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_stats_msg__descriptor) \
    , 0, 0, 0, 0, 0 }


/*
 * SECM_SESSION_REPLY 
 */
struct  SecmSessionReplyMsg
{
  ProtobufCMessage base;
  AUTHREP reply;
  GroupCfgSt *config;
  char *username;
  char *groupname;
  char *ip;
  uint32_t ipv4_seed;
  ProtobufCBinaryData sid;
  protobuf_c_boolean tls_auth_ok;
  char *vhost;
  char *user_agent;
  char *device_platform;
  char *device_type;
  int64_t session_start_time;
};
#define SECM_SESSION_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_session_reply_msg__descriptor) \
    , AUTH__REP__OK, NULL, NULL, NULL, NULL, 0, {0,NULL}, 0, NULL, NULL, NULL, NULL, 0 }


/*
 * internal struct 
 */
struct  CookieIntMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData safe_id;
  protobuf_c_boolean session_is_open;
  protobuf_c_boolean tls_auth_ok;
  uint64_t created;
  char *username;
  char *groupname;
  char *user_agent;
  char *remote_ip;
  int64_t expires;
  /*
   * the authentication status (PS_*) 
   */
  uint32_t status;
  protobuf_c_boolean in_use;
  char *vhost;
};
#define COOKIE_INT_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&cookie_int_msg__descriptor) \
    , {0,NULL}, 0, 0, 0, NULL, NULL, NULL, NULL, 0, 0, 0, NULL }


/*
 * SECM_LIST_COOKIES_REPLY 
 */
struct  SecmListCookiesReplyMsg
{
  ProtobufCMessage base;
  size_t n_cookies;
  CookieIntMsg **cookies;
};
#define SECM_LIST_COOKIES_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_list_cookies_reply_msg__descriptor) \
    , 0,NULL }


/*
 * SECM_TERMINATE_USER_SESSIONS: sent from main to sec-mod to invalidate all
 * session cookies for a given username. 
 */
struct  SecmTerminateUserSessionsMsg
{
  ProtobufCMessage base;
  char *username;
};
#define SECM_TERMINATE_USER_SESSIONS_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_terminate_user_sessions_msg__descriptor) \
    , NULL }


/*
 * SECM_TERMINATE_SESSION: sent from main to sec-mod to invalidate a single
 * session cookie by its safe_id. 
 */
struct  SecmTerminateSessionMsg
{
  ProtobufCMessage base;
  ProtobufCBinaryData safe_id;
};
#define SECM_TERMINATE_SESSION_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_terminate_session_msg__descriptor) \
    , {0,NULL} }


/*
 * Reply for both terminate commands 
 */
struct  SecmTerminateSessionReplyMsg
{
  ProtobufCMessage base;
  protobuf_c_boolean result;
};
#define SECM_TERMINATE_SESSION_REPLY_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&secm_terminate_session_reply_msg__descriptor) \
    , 0 }


/*
 * snapshot_state 
 */
struct  SnapshotStateMsg
{
  ProtobufCMessage base;
};
#define SNAPSHOT_STATE_MSG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&snapshot_state_msg__descriptor) \
     }


/* AuthCookieRequestMsg methods */
void   auth_cookie_request_msg__init
                     (AuthCookieRequestMsg         *message);
size_t auth_cookie_request_msg__get_packed_size
                     (const AuthCookieRequestMsg   *message);
size_t auth_cookie_request_msg__pack
                     (const AuthCookieRequestMsg   *message,
                      uint8_t             *out);
size_t auth_cookie_request_msg__pack_to_buffer
                     (const AuthCookieRequestMsg   *message,
                      ProtobufCBuffer     *buffer);
AuthCookieRequestMsg *
       auth_cookie_request_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   auth_cookie_request_msg__free_unpacked
                     (AuthCookieRequestMsg *message,
                      ProtobufCAllocator *allocator);
/* FwPortSt methods */
void   fw_port_st__init
                     (FwPortSt         *message);
size_t fw_port_st__get_packed_size
                     (const FwPortSt   *message);
size_t fw_port_st__pack
                     (const FwPortSt   *message,
                      uint8_t             *out);
size_t fw_port_st__pack_to_buffer
                     (const FwPortSt   *message,
                      ProtobufCBuffer     *buffer);
FwPortSt *
       fw_port_st__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   fw_port_st__free_unpacked
                     (FwPortSt *message,
                      ProtobufCAllocator *allocator);
/* GroupCfgSt methods */
void   group_cfg_st__init
                     (GroupCfgSt         *message);
size_t group_cfg_st__get_packed_size
                     (const GroupCfgSt   *message);
size_t group_cfg_st__pack
                     (const GroupCfgSt   *message,
                      uint8_t             *out);
size_t group_cfg_st__pack_to_buffer
                     (const GroupCfgSt   *message,
                      ProtobufCBuffer     *buffer);
GroupCfgSt *
       group_cfg_st__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   group_cfg_st__free_unpacked
                     (GroupCfgSt *message,
                      ProtobufCAllocator *allocator);
/* AuthCookieReplyMsg methods */
void   auth_cookie_reply_msg__init
                     (AuthCookieReplyMsg         *message);
size_t auth_cookie_reply_msg__get_packed_size
                     (const AuthCookieReplyMsg   *message);
size_t auth_cookie_reply_msg__pack
                     (const AuthCookieReplyMsg   *message,
                      uint8_t             *out);
size_t auth_cookie_reply_msg__pack_to_buffer
                     (const AuthCookieReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
AuthCookieReplyMsg *
       auth_cookie_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   auth_cookie_reply_msg__free_unpacked
                     (AuthCookieReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* SessionResumeFetchMsg methods */
void   session_resume_fetch_msg__init
                     (SessionResumeFetchMsg         *message);
size_t session_resume_fetch_msg__get_packed_size
                     (const SessionResumeFetchMsg   *message);
size_t session_resume_fetch_msg__pack
                     (const SessionResumeFetchMsg   *message,
                      uint8_t             *out);
size_t session_resume_fetch_msg__pack_to_buffer
                     (const SessionResumeFetchMsg   *message,
                      ProtobufCBuffer     *buffer);
SessionResumeFetchMsg *
       session_resume_fetch_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   session_resume_fetch_msg__free_unpacked
                     (SessionResumeFetchMsg *message,
                      ProtobufCAllocator *allocator);
/* SessionResumeStoreReqMsg methods */
void   session_resume_store_req_msg__init
                     (SessionResumeStoreReqMsg         *message);
size_t session_resume_store_req_msg__get_packed_size
                     (const SessionResumeStoreReqMsg   *message);
size_t session_resume_store_req_msg__pack
                     (const SessionResumeStoreReqMsg   *message,
                      uint8_t             *out);
size_t session_resume_store_req_msg__pack_to_buffer
                     (const SessionResumeStoreReqMsg   *message,
                      ProtobufCBuffer     *buffer);
SessionResumeStoreReqMsg *
       session_resume_store_req_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   session_resume_store_req_msg__free_unpacked
                     (SessionResumeStoreReqMsg *message,
                      ProtobufCAllocator *allocator);
/* SessionResumeReplyMsg methods */
void   session_resume_reply_msg__init
                     (SessionResumeReplyMsg         *message);
size_t session_resume_reply_msg__get_packed_size
                     (const SessionResumeReplyMsg   *message);
size_t session_resume_reply_msg__pack
                     (const SessionResumeReplyMsg   *message,
                      uint8_t             *out);
size_t session_resume_reply_msg__pack_to_buffer
                     (const SessionResumeReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
SessionResumeReplyMsg *
       session_resume_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   session_resume_reply_msg__free_unpacked
                     (SessionResumeReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* TunMtuMsg methods */
void   tun_mtu_msg__init
                     (TunMtuMsg         *message);
size_t tun_mtu_msg__get_packed_size
                     (const TunMtuMsg   *message);
size_t tun_mtu_msg__pack
                     (const TunMtuMsg   *message,
                      uint8_t             *out);
size_t tun_mtu_msg__pack_to_buffer
                     (const TunMtuMsg   *message,
                      ProtobufCBuffer     *buffer);
TunMtuMsg *
       tun_mtu_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   tun_mtu_msg__free_unpacked
                     (TunMtuMsg *message,
                      ProtobufCAllocator *allocator);
/* CliStatsMsg methods */
void   cli_stats_msg__init
                     (CliStatsMsg         *message);
size_t cli_stats_msg__get_packed_size
                     (const CliStatsMsg   *message);
size_t cli_stats_msg__pack
                     (const CliStatsMsg   *message,
                      uint8_t             *out);
size_t cli_stats_msg__pack_to_buffer
                     (const CliStatsMsg   *message,
                      ProtobufCBuffer     *buffer);
CliStatsMsg *
       cli_stats_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   cli_stats_msg__free_unpacked
                     (CliStatsMsg *message,
                      ProtobufCAllocator *allocator);
/* UdpFdMsg methods */
void   udp_fd_msg__init
                     (UdpFdMsg         *message);
size_t udp_fd_msg__get_packed_size
                     (const UdpFdMsg   *message);
size_t udp_fd_msg__pack
                     (const UdpFdMsg   *message,
                      uint8_t             *out);
size_t udp_fd_msg__pack_to_buffer
                     (const UdpFdMsg   *message,
                      ProtobufCBuffer     *buffer);
UdpFdMsg *
       udp_fd_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   udp_fd_msg__free_unpacked
                     (UdpFdMsg *message,
                      ProtobufCAllocator *allocator);
/* SnapshotEntryMsg methods */
void   snapshot_entry_msg__init
                     (SnapshotEntryMsg         *message);
size_t snapshot_entry_msg__get_packed_size
                     (const SnapshotEntryMsg   *message);
size_t snapshot_entry_msg__pack
                     (const SnapshotEntryMsg   *message,
                      uint8_t             *out);
size_t snapshot_entry_msg__pack_to_buffer
                     (const SnapshotEntryMsg   *message,
                      ProtobufCBuffer     *buffer);
SnapshotEntryMsg *
       snapshot_entry_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   snapshot_entry_msg__free_unpacked
                     (SnapshotEntryMsg *message,
                      ProtobufCAllocator *allocator);
/* WorkerStartupMsg methods */
void   worker_startup_msg__init
                     (WorkerStartupMsg         *message);
size_t worker_startup_msg__get_packed_size
                     (const WorkerStartupMsg   *message);
size_t worker_startup_msg__pack
                     (const WorkerStartupMsg   *message,
                      uint8_t             *out);
size_t worker_startup_msg__pack_to_buffer
                     (const WorkerStartupMsg   *message,
                      ProtobufCBuffer     *buffer);
WorkerStartupMsg *
       worker_startup_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   worker_startup_msg__free_unpacked
                     (WorkerStartupMsg *message,
                      ProtobufCAllocator *allocator);
/* SessionInfoMsg methods */
void   session_info_msg__init
                     (SessionInfoMsg         *message);
size_t session_info_msg__get_packed_size
                     (const SessionInfoMsg   *message);
size_t session_info_msg__pack
                     (const SessionInfoMsg   *message,
                      uint8_t             *out);
size_t session_info_msg__pack_to_buffer
                     (const SessionInfoMsg   *message,
                      ProtobufCBuffer     *buffer);
SessionInfoMsg *
       session_info_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   session_info_msg__free_unpacked
                     (SessionInfoMsg *message,
                      ProtobufCAllocator *allocator);
/* BanIpMsg methods */
void   ban_ip_msg__init
                     (BanIpMsg         *message);
size_t ban_ip_msg__get_packed_size
                     (const BanIpMsg   *message);
size_t ban_ip_msg__pack
                     (const BanIpMsg   *message,
                      uint8_t             *out);
size_t ban_ip_msg__pack_to_buffer
                     (const BanIpMsg   *message,
                      ProtobufCBuffer     *buffer);
BanIpMsg *
       ban_ip_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ban_ip_msg__free_unpacked
                     (BanIpMsg *message,
                      ProtobufCAllocator *allocator);
/* BanIpReplyMsg methods */
void   ban_ip_reply_msg__init
                     (BanIpReplyMsg         *message);
size_t ban_ip_reply_msg__get_packed_size
                     (const BanIpReplyMsg   *message);
size_t ban_ip_reply_msg__pack
                     (const BanIpReplyMsg   *message,
                      uint8_t             *out);
size_t ban_ip_reply_msg__pack_to_buffer
                     (const BanIpReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
BanIpReplyMsg *
       ban_ip_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ban_ip_reply_msg__free_unpacked
                     (BanIpReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* LatencyStatsDelta methods */
void   latency_stats_delta__init
                     (LatencyStatsDelta         *message);
size_t latency_stats_delta__get_packed_size
                     (const LatencyStatsDelta   *message);
size_t latency_stats_delta__pack
                     (const LatencyStatsDelta   *message,
                      uint8_t             *out);
size_t latency_stats_delta__pack_to_buffer
                     (const LatencyStatsDelta   *message,
                      ProtobufCBuffer     *buffer);
LatencyStatsDelta *
       latency_stats_delta__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   latency_stats_delta__free_unpacked
                     (LatencyStatsDelta *message,
                      ProtobufCAllocator *allocator);
/* SecAuthInitMsg methods */
void   sec_auth_init_msg__init
                     (SecAuthInitMsg         *message);
size_t sec_auth_init_msg__get_packed_size
                     (const SecAuthInitMsg   *message);
size_t sec_auth_init_msg__pack
                     (const SecAuthInitMsg   *message,
                      uint8_t             *out);
size_t sec_auth_init_msg__pack_to_buffer
                     (const SecAuthInitMsg   *message,
                      ProtobufCBuffer     *buffer);
SecAuthInitMsg *
       sec_auth_init_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   sec_auth_init_msg__free_unpacked
                     (SecAuthInitMsg *message,
                      ProtobufCAllocator *allocator);
/* SecAuthContMsg methods */
void   sec_auth_cont_msg__init
                     (SecAuthContMsg         *message);
size_t sec_auth_cont_msg__get_packed_size
                     (const SecAuthContMsg   *message);
size_t sec_auth_cont_msg__pack
                     (const SecAuthContMsg   *message,
                      uint8_t             *out);
size_t sec_auth_cont_msg__pack_to_buffer
                     (const SecAuthContMsg   *message,
                      ProtobufCBuffer     *buffer);
SecAuthContMsg *
       sec_auth_cont_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   sec_auth_cont_msg__free_unpacked
                     (SecAuthContMsg *message,
                      ProtobufCAllocator *allocator);
/* SecAuthReplyMsg methods */
void   sec_auth_reply_msg__init
                     (SecAuthReplyMsg         *message);
size_t sec_auth_reply_msg__get_packed_size
                     (const SecAuthReplyMsg   *message);
size_t sec_auth_reply_msg__pack
                     (const SecAuthReplyMsg   *message,
                      uint8_t             *out);
size_t sec_auth_reply_msg__pack_to_buffer
                     (const SecAuthReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
SecAuthReplyMsg *
       sec_auth_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   sec_auth_reply_msg__free_unpacked
                     (SecAuthReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* SecOpMsg methods */
void   sec_op_msg__init
                     (SecOpMsg         *message);
size_t sec_op_msg__get_packed_size
                     (const SecOpMsg   *message);
size_t sec_op_msg__pack
                     (const SecOpMsg   *message,
                      uint8_t             *out);
size_t sec_op_msg__pack_to_buffer
                     (const SecOpMsg   *message,
                      ProtobufCBuffer     *buffer);
SecOpMsg *
       sec_op_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   sec_op_msg__free_unpacked
                     (SecOpMsg *message,
                      ProtobufCAllocator *allocator);
/* SecGetPkMsg methods */
void   sec_get_pk_msg__init
                     (SecGetPkMsg         *message);
size_t sec_get_pk_msg__get_packed_size
                     (const SecGetPkMsg   *message);
size_t sec_get_pk_msg__pack
                     (const SecGetPkMsg   *message,
                      uint8_t             *out);
size_t sec_get_pk_msg__pack_to_buffer
                     (const SecGetPkMsg   *message,
                      ProtobufCBuffer     *buffer);
SecGetPkMsg *
       sec_get_pk_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   sec_get_pk_msg__free_unpacked
                     (SecGetPkMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmSessionOpenMsg methods */
void   secm_session_open_msg__init
                     (SecmSessionOpenMsg         *message);
size_t secm_session_open_msg__get_packed_size
                     (const SecmSessionOpenMsg   *message);
size_t secm_session_open_msg__pack
                     (const SecmSessionOpenMsg   *message,
                      uint8_t             *out);
size_t secm_session_open_msg__pack_to_buffer
                     (const SecmSessionOpenMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmSessionOpenMsg *
       secm_session_open_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_session_open_msg__free_unpacked
                     (SecmSessionOpenMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmSessionCloseMsg methods */
void   secm_session_close_msg__init
                     (SecmSessionCloseMsg         *message);
size_t secm_session_close_msg__get_packed_size
                     (const SecmSessionCloseMsg   *message);
size_t secm_session_close_msg__pack
                     (const SecmSessionCloseMsg   *message,
                      uint8_t             *out);
size_t secm_session_close_msg__pack_to_buffer
                     (const SecmSessionCloseMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmSessionCloseMsg *
       secm_session_close_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_session_close_msg__free_unpacked
                     (SecmSessionCloseMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmStatsMsg methods */
void   secm_stats_msg__init
                     (SecmStatsMsg         *message);
size_t secm_stats_msg__get_packed_size
                     (const SecmStatsMsg   *message);
size_t secm_stats_msg__pack
                     (const SecmStatsMsg   *message,
                      uint8_t             *out);
size_t secm_stats_msg__pack_to_buffer
                     (const SecmStatsMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmStatsMsg *
       secm_stats_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_stats_msg__free_unpacked
                     (SecmStatsMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmSessionReplyMsg methods */
void   secm_session_reply_msg__init
                     (SecmSessionReplyMsg         *message);
size_t secm_session_reply_msg__get_packed_size
                     (const SecmSessionReplyMsg   *message);
size_t secm_session_reply_msg__pack
                     (const SecmSessionReplyMsg   *message,
                      uint8_t             *out);
size_t secm_session_reply_msg__pack_to_buffer
                     (const SecmSessionReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmSessionReplyMsg *
       secm_session_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_session_reply_msg__free_unpacked
                     (SecmSessionReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* CookieIntMsg methods */
void   cookie_int_msg__init
                     (CookieIntMsg         *message);
size_t cookie_int_msg__get_packed_size
                     (const CookieIntMsg   *message);
size_t cookie_int_msg__pack
                     (const CookieIntMsg   *message,
                      uint8_t             *out);
size_t cookie_int_msg__pack_to_buffer
                     (const CookieIntMsg   *message,
                      ProtobufCBuffer     *buffer);
CookieIntMsg *
       cookie_int_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   cookie_int_msg__free_unpacked
                     (CookieIntMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmListCookiesReplyMsg methods */
void   secm_list_cookies_reply_msg__init
                     (SecmListCookiesReplyMsg         *message);
size_t secm_list_cookies_reply_msg__get_packed_size
                     (const SecmListCookiesReplyMsg   *message);
size_t secm_list_cookies_reply_msg__pack
                     (const SecmListCookiesReplyMsg   *message,
                      uint8_t             *out);
size_t secm_list_cookies_reply_msg__pack_to_buffer
                     (const SecmListCookiesReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmListCookiesReplyMsg *
       secm_list_cookies_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_list_cookies_reply_msg__free_unpacked
                     (SecmListCookiesReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmTerminateUserSessionsMsg methods */
void   secm_terminate_user_sessions_msg__init
                     (SecmTerminateUserSessionsMsg         *message);
size_t secm_terminate_user_sessions_msg__get_packed_size
                     (const SecmTerminateUserSessionsMsg   *message);
size_t secm_terminate_user_sessions_msg__pack
                     (const SecmTerminateUserSessionsMsg   *message,
                      uint8_t             *out);
size_t secm_terminate_user_sessions_msg__pack_to_buffer
                     (const SecmTerminateUserSessionsMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmTerminateUserSessionsMsg *
       secm_terminate_user_sessions_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_terminate_user_sessions_msg__free_unpacked
                     (SecmTerminateUserSessionsMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmTerminateSessionMsg methods */
void   secm_terminate_session_msg__init
                     (SecmTerminateSessionMsg         *message);
size_t secm_terminate_session_msg__get_packed_size
                     (const SecmTerminateSessionMsg   *message);
size_t secm_terminate_session_msg__pack
                     (const SecmTerminateSessionMsg   *message,
                      uint8_t             *out);
size_t secm_terminate_session_msg__pack_to_buffer
                     (const SecmTerminateSessionMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmTerminateSessionMsg *
       secm_terminate_session_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_terminate_session_msg__free_unpacked
                     (SecmTerminateSessionMsg *message,
                      ProtobufCAllocator *allocator);
/* SecmTerminateSessionReplyMsg methods */
void   secm_terminate_session_reply_msg__init
                     (SecmTerminateSessionReplyMsg         *message);
size_t secm_terminate_session_reply_msg__get_packed_size
                     (const SecmTerminateSessionReplyMsg   *message);
size_t secm_terminate_session_reply_msg__pack
                     (const SecmTerminateSessionReplyMsg   *message,
                      uint8_t             *out);
size_t secm_terminate_session_reply_msg__pack_to_buffer
                     (const SecmTerminateSessionReplyMsg   *message,
                      ProtobufCBuffer     *buffer);
SecmTerminateSessionReplyMsg *
       secm_terminate_session_reply_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   secm_terminate_session_reply_msg__free_unpacked
                     (SecmTerminateSessionReplyMsg *message,
                      ProtobufCAllocator *allocator);
/* SnapshotStateMsg methods */
void   snapshot_state_msg__init
                     (SnapshotStateMsg         *message);
size_t snapshot_state_msg__get_packed_size
                     (const SnapshotStateMsg   *message);
size_t snapshot_state_msg__pack
                     (const SnapshotStateMsg   *message,
                      uint8_t             *out);
size_t snapshot_state_msg__pack_to_buffer
                     (const SnapshotStateMsg   *message,
                      ProtobufCBuffer     *buffer);
SnapshotStateMsg *
       snapshot_state_msg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   snapshot_state_msg__free_unpacked
                     (SnapshotStateMsg *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*AuthCookieRequestMsg_Closure)
                 (const AuthCookieRequestMsg *message,
                  void *closure_data);
typedef void (*FwPortSt_Closure)
                 (const FwPortSt *message,
                  void *closure_data);
typedef void (*GroupCfgSt_Closure)
                 (const GroupCfgSt *message,
                  void *closure_data);
typedef void (*AuthCookieReplyMsg_Closure)
                 (const AuthCookieReplyMsg *message,
                  void *closure_data);
typedef void (*SessionResumeFetchMsg_Closure)
                 (const SessionResumeFetchMsg *message,
                  void *closure_data);
typedef void (*SessionResumeStoreReqMsg_Closure)
                 (const SessionResumeStoreReqMsg *message,
                  void *closure_data);
typedef void (*SessionResumeReplyMsg_Closure)
                 (const SessionResumeReplyMsg *message,
                  void *closure_data);
typedef void (*TunMtuMsg_Closure)
                 (const TunMtuMsg *message,
                  void *closure_data);
typedef void (*CliStatsMsg_Closure)
                 (const CliStatsMsg *message,
                  void *closure_data);
typedef void (*UdpFdMsg_Closure)
                 (const UdpFdMsg *message,
                  void *closure_data);
typedef void (*SnapshotEntryMsg_Closure)
                 (const SnapshotEntryMsg *message,
                  void *closure_data);
typedef void (*WorkerStartupMsg_Closure)
                 (const WorkerStartupMsg *message,
                  void *closure_data);
typedef void (*SessionInfoMsg_Closure)
                 (const SessionInfoMsg *message,
                  void *closure_data);
typedef void (*BanIpMsg_Closure)
                 (const BanIpMsg *message,
                  void *closure_data);
typedef void (*BanIpReplyMsg_Closure)
                 (const BanIpReplyMsg *message,
                  void *closure_data);
typedef void (*LatencyStatsDelta_Closure)
                 (const LatencyStatsDelta *message,
                  void *closure_data);
typedef void (*SecAuthInitMsg_Closure)
                 (const SecAuthInitMsg *message,
                  void *closure_data);
typedef void (*SecAuthContMsg_Closure)
                 (const SecAuthContMsg *message,
                  void *closure_data);
typedef void (*SecAuthReplyMsg_Closure)
                 (const SecAuthReplyMsg *message,
                  void *closure_data);
typedef void (*SecOpMsg_Closure)
                 (const SecOpMsg *message,
                  void *closure_data);
typedef void (*SecGetPkMsg_Closure)
                 (const SecGetPkMsg *message,
                  void *closure_data);
typedef void (*SecmSessionOpenMsg_Closure)
                 (const SecmSessionOpenMsg *message,
                  void *closure_data);
typedef void (*SecmSessionCloseMsg_Closure)
                 (const SecmSessionCloseMsg *message,
                  void *closure_data);
typedef void (*SecmStatsMsg_Closure)
                 (const SecmStatsMsg *message,
                  void *closure_data);
typedef void (*SecmSessionReplyMsg_Closure)
                 (const SecmSessionReplyMsg *message,
                  void *closure_data);
typedef void (*CookieIntMsg_Closure)
                 (const CookieIntMsg *message,
                  void *closure_data);
typedef void (*SecmListCookiesReplyMsg_Closure)
                 (const SecmListCookiesReplyMsg *message,
                  void *closure_data);
typedef void (*SecmTerminateUserSessionsMsg_Closure)
                 (const SecmTerminateUserSessionsMsg *message,
                  void *closure_data);
typedef void (*SecmTerminateSessionMsg_Closure)
                 (const SecmTerminateSessionMsg *message,
                  void *closure_data);
typedef void (*SecmTerminateSessionReplyMsg_Closure)
                 (const SecmTerminateSessionReplyMsg *message,
                  void *closure_data);
typedef void (*SnapshotStateMsg_Closure)
                 (const SnapshotStateMsg *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCEnumDescriptor    auth__rep__descriptor;
extern const ProtobufCMessageDescriptor auth_cookie_request_msg__descriptor;
extern const ProtobufCMessageDescriptor fw_port_st__descriptor;
extern const ProtobufCMessageDescriptor group_cfg_st__descriptor;
extern const ProtobufCMessageDescriptor auth_cookie_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor session_resume_fetch_msg__descriptor;
extern const ProtobufCMessageDescriptor session_resume_store_req_msg__descriptor;
extern const ProtobufCMessageDescriptor session_resume_reply_msg__descriptor;
extern const ProtobufCEnumDescriptor    session_resume_reply_msg__resume__rep__descriptor;
extern const ProtobufCMessageDescriptor tun_mtu_msg__descriptor;
extern const ProtobufCMessageDescriptor cli_stats_msg__descriptor;
extern const ProtobufCMessageDescriptor udp_fd_msg__descriptor;
extern const ProtobufCMessageDescriptor snapshot_entry_msg__descriptor;
extern const ProtobufCMessageDescriptor worker_startup_msg__descriptor;
extern const ProtobufCEnumDescriptor    worker_startup_msg__conn__type__descriptor;
extern const ProtobufCMessageDescriptor session_info_msg__descriptor;
extern const ProtobufCMessageDescriptor ban_ip_msg__descriptor;
extern const ProtobufCMessageDescriptor ban_ip_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor latency_stats_delta__descriptor;
extern const ProtobufCMessageDescriptor sec_auth_init_msg__descriptor;
extern const ProtobufCMessageDescriptor sec_auth_cont_msg__descriptor;
extern const ProtobufCMessageDescriptor sec_auth_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor sec_op_msg__descriptor;
extern const ProtobufCMessageDescriptor sec_get_pk_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_session_open_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_session_close_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_stats_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_session_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor cookie_int_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_list_cookies_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_terminate_user_sessions_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_terminate_session_msg__descriptor;
extern const ProtobufCMessageDescriptor secm_terminate_session_reply_msg__descriptor;
extern const ProtobufCMessageDescriptor snapshot_state_msg__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_ipc_2eproto__INCLUDED */
