#ifndef __included_vpncrack_api_json
#define __included_vpncrack_api_json

#include <stdlib.h>
#include <stddef.h>
#include <arpa/inet.h>
#include <vapi/vapi_internal.h>
#include <vapi/vapi.h>
#include <vapi/vapi_dbg.h>

#ifdef __cplusplus
extern "C" {
#endif
#include <vapi/vpe.api.vapi.h>

extern vapi_msg_id_t vapi_msg_id_vpncrack_decrypt_event;
extern vapi_msg_id_t vapi_msg_id_vpncrack_timesync_event;
extern vapi_msg_id_t vapi_msg_id_want_vpncrack_decrypt_event_reply;
extern vapi_msg_id_t vapi_msg_id_want_vpncrack_timesync_event_reply;
extern vapi_msg_id_t vapi_msg_id_vpncrack_globle_config;
extern vapi_msg_id_t vapi_msg_id_vpncrack_pwh_clean;
extern vapi_msg_id_t vapi_msg_id_vpncrack_pwh_update;
extern vapi_msg_id_t vapi_msg_id_vpncrack_globle_config_reply;
extern vapi_msg_id_t vapi_msg_id_vpncrack_pwh_clean_reply;
extern vapi_msg_id_t vapi_msg_id_vpncrack_pwh_update_reply;
extern vapi_msg_id_t vapi_msg_id_want_vpncrack_timesync_event;
extern vapi_msg_id_t vapi_msg_id_want_vpncrack_decrypt_event;

#define DEFINE_VAPI_MSG_IDS_VPNCRACK_API_JSON\
  vapi_msg_id_t vapi_msg_id_vpncrack_decrypt_event;\
  vapi_msg_id_t vapi_msg_id_vpncrack_timesync_event;\
  vapi_msg_id_t vapi_msg_id_want_vpncrack_decrypt_event_reply;\
  vapi_msg_id_t vapi_msg_id_want_vpncrack_timesync_event_reply;\
  vapi_msg_id_t vapi_msg_id_vpncrack_globle_config;\
  vapi_msg_id_t vapi_msg_id_vpncrack_pwh_clean;\
  vapi_msg_id_t vapi_msg_id_vpncrack_pwh_update;\
  vapi_msg_id_t vapi_msg_id_vpncrack_globle_config_reply;\
  vapi_msg_id_t vapi_msg_id_vpncrack_pwh_clean_reply;\
  vapi_msg_id_t vapi_msg_id_vpncrack_pwh_update_reply;\
  vapi_msg_id_t vapi_msg_id_want_vpncrack_timesync_event;\
  vapi_msg_id_t vapi_msg_id_want_vpncrack_decrypt_event;


typedef struct __attribute__ ((__packed__)) {
  u32 pid;
  u8 event_type;
  u8 flag;
  u8 username[257];
  u32 userNameLength;
  u32 serverip;
  u32 clientip;
  u64 on_time;
  u8 IMSI[8];
  u8 MSISDN[8];
  u8 challenge_mid[8];
  u8 ntRespond[24];
  u64 off_time;
  u8 ntPasswordHash[16];
  u8 domain_name[255];
  u32 domainNameLength; 
} vapi_payload_vpncrack_decrypt_event;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_vpncrack_decrypt_event payload;
} vapi_msg_vpncrack_decrypt_event;

typedef struct __attribute__ ((__packed__)) {
  u32 pid;
  u8 board_type;
  u8 frame_num;
  u8 event_type;
  u8 seq;
  u8 entry_num;
  u64 timestamp;
  u32 body_len; 
} vapi_payload_vpncrack_timesync_event;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_vpncrack_timesync_event payload;
} vapi_msg_vpncrack_timesync_event;

typedef struct __attribute__ ((__packed__)) {
  u32 retval; 
} vapi_payload_want_vpncrack_decrypt_event_reply;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header1_t header;
  vapi_payload_want_vpncrack_decrypt_event_reply payload;
} vapi_msg_want_vpncrack_decrypt_event_reply;

typedef struct __attribute__ ((__packed__)) {
  u32 retval; 
} vapi_payload_want_vpncrack_timesync_event_reply;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header1_t header;
  vapi_payload_want_vpncrack_timesync_event_reply payload;
} vapi_msg_want_vpncrack_timesync_event_reply;

typedef struct __attribute__ ((__packed__)) {
  u8 is_add;
  u8 global_src_mac[6];
  u32 global_local_ip; 
} vapi_payload_vpncrack_globle_config;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_vpncrack_globle_config payload;
} vapi_msg_vpncrack_globle_config;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
} vapi_msg_vpncrack_pwh_clean;

typedef struct __attribute__ ((__packed__)) {
  u32 serverip;
  u8 pwh[16];
  u32 ulen;
  u8 username[257]; 
} vapi_payload_vpncrack_pwh_update;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_vpncrack_pwh_update payload;
} vapi_msg_vpncrack_pwh_update;

typedef struct __attribute__ ((__packed__)) {
  u32 retval; 
} vapi_payload_vpncrack_globle_config_reply;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header1_t header;
  vapi_payload_vpncrack_globle_config_reply payload;
} vapi_msg_vpncrack_globle_config_reply;

typedef struct __attribute__ ((__packed__)) {
  u32 retval; 
} vapi_payload_vpncrack_pwh_clean_reply;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header1_t header;
  vapi_payload_vpncrack_pwh_clean_reply payload;
} vapi_msg_vpncrack_pwh_clean_reply;

typedef struct __attribute__ ((__packed__)) {
  u32 retval; 
} vapi_payload_vpncrack_pwh_update_reply;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header1_t header;
  vapi_payload_vpncrack_pwh_update_reply payload;
} vapi_msg_vpncrack_pwh_update_reply;

typedef struct __attribute__ ((__packed__)) {
  u32 pid;
  u32 enable; 
} vapi_payload_want_vpncrack_timesync_event;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_want_vpncrack_timesync_event payload;
} vapi_msg_want_vpncrack_timesync_event;

typedef struct __attribute__ ((__packed__)) {
  u32 pid;
  u32 enable; 
} vapi_payload_want_vpncrack_decrypt_event;

typedef struct __attribute__ ((__packed__)) {
  vapi_type_msg_header2_t header;
  vapi_payload_want_vpncrack_decrypt_event payload;
} vapi_msg_want_vpncrack_decrypt_event;


static inline void vapi_msg_vpncrack_decrypt_event_payload_hton(vapi_payload_vpncrack_decrypt_event *payload)
{
  payload->pid = htobe32(payload->pid);
  payload->userNameLength = htobe32(payload->userNameLength);
  payload->serverip = htobe32(payload->serverip);
  payload->clientip = htobe32(payload->clientip);
  payload->on_time = htobe64(payload->on_time);
  payload->off_time = htobe64(payload->off_time);
  payload->domainNameLength = htobe32(payload->domainNameLength);
}

static inline void vapi_msg_vpncrack_decrypt_event_payload_ntoh(vapi_payload_vpncrack_decrypt_event *payload)
{
  payload->pid = be32toh(payload->pid);
  payload->userNameLength = be32toh(payload->userNameLength);
  payload->serverip = be32toh(payload->serverip);
  payload->clientip = be32toh(payload->clientip);
  payload->on_time = be64toh(payload->on_time);
  payload->off_time = be64toh(payload->off_time);
  payload->domainNameLength = be32toh(payload->domainNameLength);
}

static inline uword vapi_calc_vpncrack_decrypt_event_msg_size(vapi_msg_vpncrack_decrypt_event *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_decrypt_event_hton(vapi_msg_vpncrack_decrypt_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_decrypt_event'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_vpncrack_decrypt_event_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_decrypt_event_ntoh(vapi_msg_vpncrack_decrypt_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_decrypt_event'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_vpncrack_decrypt_event_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_vpncrack_timesync_event_payload_hton(vapi_payload_vpncrack_timesync_event *payload)
{
  payload->pid = htobe32(payload->pid);
  payload->timestamp = htobe64(payload->timestamp);
  payload->body_len = htobe32(payload->body_len);
}

static inline void vapi_msg_vpncrack_timesync_event_payload_ntoh(vapi_payload_vpncrack_timesync_event *payload)
{
  payload->pid = be32toh(payload->pid);
  payload->timestamp = be64toh(payload->timestamp);
  payload->body_len = be32toh(payload->body_len);
}

static inline uword vapi_calc_vpncrack_timesync_event_msg_size(vapi_msg_vpncrack_timesync_event *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_timesync_event_hton(vapi_msg_vpncrack_timesync_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_timesync_event'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_vpncrack_timesync_event_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_timesync_event_ntoh(vapi_msg_vpncrack_timesync_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_timesync_event'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_vpncrack_timesync_event_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_reply_payload_hton(vapi_payload_want_vpncrack_decrypt_event_reply *payload)
{
  payload->retval = htobe32(payload->retval);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_reply_payload_ntoh(vapi_payload_want_vpncrack_decrypt_event_reply *payload)
{
  payload->retval = be32toh(payload->retval);
}

static inline uword vapi_calc_want_vpncrack_decrypt_event_reply_msg_size(vapi_msg_want_vpncrack_decrypt_event_reply *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_reply_hton(vapi_msg_want_vpncrack_decrypt_event_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_decrypt_event_reply'@%p to big endian", msg);
  vapi_type_msg_header1_t_hton(&msg->header);
  vapi_msg_want_vpncrack_decrypt_event_reply_payload_hton(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_reply_ntoh(vapi_msg_want_vpncrack_decrypt_event_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_decrypt_event_reply'@%p to host byte order", msg);
  vapi_type_msg_header1_t_ntoh(&msg->header);
  vapi_msg_want_vpncrack_decrypt_event_reply_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_timesync_event_reply_payload_hton(vapi_payload_want_vpncrack_timesync_event_reply *payload)
{
  payload->retval = htobe32(payload->retval);
}

static inline void vapi_msg_want_vpncrack_timesync_event_reply_payload_ntoh(vapi_payload_want_vpncrack_timesync_event_reply *payload)
{
  payload->retval = be32toh(payload->retval);
}

static inline uword vapi_calc_want_vpncrack_timesync_event_reply_msg_size(vapi_msg_want_vpncrack_timesync_event_reply *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_want_vpncrack_timesync_event_reply_hton(vapi_msg_want_vpncrack_timesync_event_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_timesync_event_reply'@%p to big endian", msg);
  vapi_type_msg_header1_t_hton(&msg->header);
  vapi_msg_want_vpncrack_timesync_event_reply_payload_hton(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_timesync_event_reply_ntoh(vapi_msg_want_vpncrack_timesync_event_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_timesync_event_reply'@%p to host byte order", msg);
  vapi_type_msg_header1_t_ntoh(&msg->header);
  vapi_msg_want_vpncrack_timesync_event_reply_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_vpncrack_globle_config_payload_hton(vapi_payload_vpncrack_globle_config *payload)
{
  payload->global_local_ip = htobe32(payload->global_local_ip);
}

static inline void vapi_msg_vpncrack_globle_config_payload_ntoh(vapi_payload_vpncrack_globle_config *payload)
{
  payload->global_local_ip = be32toh(payload->global_local_ip);
}

static inline uword vapi_calc_vpncrack_globle_config_msg_size(vapi_msg_vpncrack_globle_config *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_globle_config_hton(vapi_msg_vpncrack_globle_config *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_globle_config'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_vpncrack_globle_config_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_globle_config_ntoh(vapi_msg_vpncrack_globle_config *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_globle_config'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_vpncrack_globle_config_payload_ntoh(&msg->payload);
}

static inline uword vapi_calc_vpncrack_pwh_clean_msg_size(vapi_msg_vpncrack_pwh_clean *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_pwh_clean_hton(vapi_msg_vpncrack_pwh_clean *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_clean'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);

}

static inline void vapi_msg_vpncrack_pwh_clean_ntoh(vapi_msg_vpncrack_pwh_clean *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_clean'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);

}

static inline void vapi_msg_vpncrack_pwh_update_payload_hton(vapi_payload_vpncrack_pwh_update *payload)
{
  payload->serverip = htobe32(payload->serverip);
  payload->ulen = htobe32(payload->ulen);
}

static inline void vapi_msg_vpncrack_pwh_update_payload_ntoh(vapi_payload_vpncrack_pwh_update *payload)
{
  payload->serverip = be32toh(payload->serverip);
  payload->ulen = be32toh(payload->ulen);
}

static inline uword vapi_calc_vpncrack_pwh_update_msg_size(vapi_msg_vpncrack_pwh_update *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_pwh_update_hton(vapi_msg_vpncrack_pwh_update *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_update'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_vpncrack_pwh_update_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_pwh_update_ntoh(vapi_msg_vpncrack_pwh_update *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_update'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_vpncrack_pwh_update_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_vpncrack_globle_config_reply_payload_hton(vapi_payload_vpncrack_globle_config_reply *payload)
{
  payload->retval = htobe32(payload->retval);
}

static inline void vapi_msg_vpncrack_globle_config_reply_payload_ntoh(vapi_payload_vpncrack_globle_config_reply *payload)
{
  payload->retval = be32toh(payload->retval);
}

static inline uword vapi_calc_vpncrack_globle_config_reply_msg_size(vapi_msg_vpncrack_globle_config_reply *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_globle_config_reply_hton(vapi_msg_vpncrack_globle_config_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_globle_config_reply'@%p to big endian", msg);
  vapi_type_msg_header1_t_hton(&msg->header);
  vapi_msg_vpncrack_globle_config_reply_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_globle_config_reply_ntoh(vapi_msg_vpncrack_globle_config_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_globle_config_reply'@%p to host byte order", msg);
  vapi_type_msg_header1_t_ntoh(&msg->header);
  vapi_msg_vpncrack_globle_config_reply_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_vpncrack_pwh_clean_reply_payload_hton(vapi_payload_vpncrack_pwh_clean_reply *payload)
{
  payload->retval = htobe32(payload->retval);
}

static inline void vapi_msg_vpncrack_pwh_clean_reply_payload_ntoh(vapi_payload_vpncrack_pwh_clean_reply *payload)
{
  payload->retval = be32toh(payload->retval);
}

static inline uword vapi_calc_vpncrack_pwh_clean_reply_msg_size(vapi_msg_vpncrack_pwh_clean_reply *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_pwh_clean_reply_hton(vapi_msg_vpncrack_pwh_clean_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_clean_reply'@%p to big endian", msg);
  vapi_type_msg_header1_t_hton(&msg->header);
  vapi_msg_vpncrack_pwh_clean_reply_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_pwh_clean_reply_ntoh(vapi_msg_vpncrack_pwh_clean_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_clean_reply'@%p to host byte order", msg);
  vapi_type_msg_header1_t_ntoh(&msg->header);
  vapi_msg_vpncrack_pwh_clean_reply_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_vpncrack_pwh_update_reply_payload_hton(vapi_payload_vpncrack_pwh_update_reply *payload)
{
  payload->retval = htobe32(payload->retval);
}

static inline void vapi_msg_vpncrack_pwh_update_reply_payload_ntoh(vapi_payload_vpncrack_pwh_update_reply *payload)
{
  payload->retval = be32toh(payload->retval);
}

static inline uword vapi_calc_vpncrack_pwh_update_reply_msg_size(vapi_msg_vpncrack_pwh_update_reply *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_vpncrack_pwh_update_reply_hton(vapi_msg_vpncrack_pwh_update_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_update_reply'@%p to big endian", msg);
  vapi_type_msg_header1_t_hton(&msg->header);
  vapi_msg_vpncrack_pwh_update_reply_payload_hton(&msg->payload);
}

static inline void vapi_msg_vpncrack_pwh_update_reply_ntoh(vapi_msg_vpncrack_pwh_update_reply *msg)
{
  VAPI_DBG("Swapping `vapi_msg_vpncrack_pwh_update_reply'@%p to host byte order", msg);
  vapi_type_msg_header1_t_ntoh(&msg->header);
  vapi_msg_vpncrack_pwh_update_reply_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_timesync_event_payload_hton(vapi_payload_want_vpncrack_timesync_event *payload)
{
  payload->pid = htobe32(payload->pid);
  payload->enable = htobe32(payload->enable);
}

static inline void vapi_msg_want_vpncrack_timesync_event_payload_ntoh(vapi_payload_want_vpncrack_timesync_event *payload)
{
  payload->pid = be32toh(payload->pid);
  payload->enable = be32toh(payload->enable);
}

static inline uword vapi_calc_want_vpncrack_timesync_event_msg_size(vapi_msg_want_vpncrack_timesync_event *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_want_vpncrack_timesync_event_hton(vapi_msg_want_vpncrack_timesync_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_timesync_event'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_want_vpncrack_timesync_event_payload_hton(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_timesync_event_ntoh(vapi_msg_want_vpncrack_timesync_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_timesync_event'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_want_vpncrack_timesync_event_payload_ntoh(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_payload_hton(vapi_payload_want_vpncrack_decrypt_event *payload)
{
  payload->pid = htobe32(payload->pid);
  payload->enable = htobe32(payload->enable);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_payload_ntoh(vapi_payload_want_vpncrack_decrypt_event *payload)
{
  payload->pid = be32toh(payload->pid);
  payload->enable = be32toh(payload->enable);
}

static inline uword vapi_calc_want_vpncrack_decrypt_event_msg_size(vapi_msg_want_vpncrack_decrypt_event *msg)
{
  return sizeof(*msg);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_hton(vapi_msg_want_vpncrack_decrypt_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_decrypt_event'@%p to big endian", msg);
  vapi_type_msg_header2_t_hton(&msg->header);
  vapi_msg_want_vpncrack_decrypt_event_payload_hton(&msg->payload);
}

static inline void vapi_msg_want_vpncrack_decrypt_event_ntoh(vapi_msg_want_vpncrack_decrypt_event *msg)
{
  VAPI_DBG("Swapping `vapi_msg_want_vpncrack_decrypt_event'@%p to host byte order", msg);
  vapi_type_msg_header2_t_ntoh(&msg->header);
  vapi_msg_want_vpncrack_decrypt_event_payload_ntoh(&msg->payload);
}

static inline vapi_msg_vpncrack_globle_config* vapi_alloc_vpncrack_globle_config(struct vapi_ctx_s *ctx)
{
  vapi_msg_vpncrack_globle_config *msg = NULL;
  const size_t size = sizeof(vapi_msg_vpncrack_globle_config);
  /* cast here required to play nicely with C++ world ... */
  msg = (vapi_msg_vpncrack_globle_config*)vapi_msg_alloc(ctx, size);
  if (!msg) {
    return NULL;
  }
  msg->header.client_index = vapi_get_client_index(ctx);
  msg->header.context = 0;
  msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, vapi_msg_id_vpncrack_globle_config);

  return msg;
}

static inline vapi_error_e vapi_vpncrack_globle_config(struct vapi_ctx_s *ctx,
  vapi_msg_vpncrack_globle_config *msg,
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx,
                           void *callback_ctx,
                           vapi_error_e rv,
                           bool is_last,
                           vapi_payload_vpncrack_globle_config_reply *reply),
  void *callback_ctx)
{
  if (!msg || !callback) {
    return VAPI_EINVAL;
  }
  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {
    return VAPI_EAGAIN;
  }
  vapi_error_e rv;
  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {
    return rv;
  }
  u32 req_context = vapi_gen_req_context(ctx);
  msg->header.context = req_context;
  vapi_msg_vpncrack_globle_config_hton(msg);
  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {
    vapi_store_request(ctx, req_context, false, (vapi_cb_t)callback, callback_ctx);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
    if (vapi_is_nonblocking(ctx)) {
      rv = VAPI_OK;
    } else {
      rv = vapi_dispatch(ctx);
    }
  } else {
    vapi_msg_vpncrack_globle_config_ntoh(msg);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
  }
  return rv;
}


static inline vapi_msg_vpncrack_pwh_clean* vapi_alloc_vpncrack_pwh_clean(struct vapi_ctx_s *ctx)
{
  vapi_msg_vpncrack_pwh_clean *msg = NULL;
  const size_t size = sizeof(vapi_msg_vpncrack_pwh_clean);
  /* cast here required to play nicely with C++ world ... */
  msg = (vapi_msg_vpncrack_pwh_clean*)vapi_msg_alloc(ctx, size);
  if (!msg) {
    return NULL;
  }
  msg->header.client_index = vapi_get_client_index(ctx);
  msg->header.context = 0;
  msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, vapi_msg_id_vpncrack_pwh_clean);

  return msg;
}

static inline vapi_error_e vapi_vpncrack_pwh_clean(struct vapi_ctx_s *ctx,
  vapi_msg_vpncrack_pwh_clean *msg,
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx,
                           void *callback_ctx,
                           vapi_error_e rv,
                           bool is_last,
                           vapi_payload_vpncrack_pwh_clean_reply *reply),
  void *callback_ctx)
{
  if (!msg || !callback) {
    return VAPI_EINVAL;
  }
  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {
    return VAPI_EAGAIN;
  }
  vapi_error_e rv;
  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {
    return rv;
  }
  u32 req_context = vapi_gen_req_context(ctx);
  msg->header.context = req_context;
  vapi_msg_vpncrack_pwh_clean_hton(msg);
  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {
    vapi_store_request(ctx, req_context, false, (vapi_cb_t)callback, callback_ctx);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
    if (vapi_is_nonblocking(ctx)) {
      rv = VAPI_OK;
    } else {
      rv = vapi_dispatch(ctx);
    }
  } else {
    vapi_msg_vpncrack_pwh_clean_ntoh(msg);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
  }
  return rv;
}


static inline vapi_msg_vpncrack_pwh_update* vapi_alloc_vpncrack_pwh_update(struct vapi_ctx_s *ctx)
{
  vapi_msg_vpncrack_pwh_update *msg = NULL;
  const size_t size = sizeof(vapi_msg_vpncrack_pwh_update);
  /* cast here required to play nicely with C++ world ... */
  msg = (vapi_msg_vpncrack_pwh_update*)vapi_msg_alloc(ctx, size);
  if (!msg) {
    return NULL;
  }
  msg->header.client_index = vapi_get_client_index(ctx);
  msg->header.context = 0;
  msg->header._vl_msg_id = vapi_lookup_vl_msg_id(ctx, vapi_msg_id_vpncrack_pwh_update);

  return msg;
}

static inline vapi_error_e vapi_vpncrack_pwh_update(struct vapi_ctx_s *ctx,
  vapi_msg_vpncrack_pwh_update *msg,
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx,
                           void *callback_ctx,
                           vapi_error_e rv,
                           bool is_last,
                           vapi_payload_vpncrack_pwh_update_reply *reply),
  void *callback_ctx)
{
  if (!msg || !callback) {
    return VAPI_EINVAL;
  }
  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {
    return VAPI_EAGAIN;
  }
  vapi_error_e rv;
  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {
    return rv;
  }
  u32 req_context = vapi_gen_req_context(ctx);
  msg->header.context = req_context;
  vapi_msg_vpncrack_pwh_update_hton(msg);
  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {
    vapi_store_request(ctx, req_context, false, (vapi_cb_t)callback, callback_ctx);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
    if (vapi_is_nonblocking(ctx)) {
      rv = VAPI_OK;
    } else {
      rv = vapi_dispatch(ctx);
    }
  } else {
    vapi_msg_vpncrack_pwh_update_ntoh(msg);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
  }
  return rv;
}

static inline vapi_msg_want_vpncrack_decrypt_event(struct vapi_ctx_s *ctx)
{
    vapi_msg_want_vpncrack_decrypt_event *msg =NULL;
    const size_t size = sizeof(vapi_msg_want_vpncrack_decrypt_event);
    msg = (vapi_msg_want_vpncrack_decrypt_event*)vapi_msg_alloc(ctx, size);
    if(!msg){
    return NULL;
    }
    msg->header.client_index = vapi_get client_index(ctx);
    msg->header.context = 0;
    msg->header._vl_msg_id = vapi_lookup_vl_mas_id(ctx, vapi_msg_id_want_vpncrack_decrypt_event);
    
    return msg;
}
static inline vapi_error_e vapi_want_vpncrack_decrypt_event(struct vapi_ctx_s *ctx,
  vapi_msg_want_vpncrack_decrypt_event *msg,
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx,
                           void *callback_ctx,
                           vapi_error_e rv,
                           bool is_last,
                           vapi_payload_want_vpncrack_decrypt_event_reply *reply),
  void *callback_ctx)
{
  if (!msg || !callback) {
    return VAPI_EINVAL;
  }
  if (vapi_is_nonblocking(ctx) && vapi_requests_full(ctx)) {
    return VAPI_EAGAIN;
  }
  vapi_error_e rv;
  if (VAPI_OK != (rv = vapi_producer_lock (ctx))) {
    return rv;
  }
  u32 req_context = vapi_gen_req_context(ctx);
  msg->header.context = req_context;
  vapi_msg_want_vpncrack_decrypt_event_hton(msg);
  if (VAPI_OK == (rv = vapi_send (ctx, msg))) {
    vapi_store_request(ctx, req_context, false, (vapi_cb_t)callback, callback_ctx);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
    if (vapi_is_nonblocking(ctx)) {
      rv = VAPI_OK;
    } else {
      rv = vapi_dispatch(ctx);
    }
  } else {
    vapi_msg_want_vpncrack_decrypt_event_ntoh(msg);
    if (VAPI_OK != vapi_producer_unlock (ctx)) {
      abort (); /* this really shouldn't happen */
    }
  }
  return rv;
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_decrypt_event()
{
  static const char name[] = "vpncrack_decrypt_event";
  static const char name_with_crc[] = "vpncrack_decrypt_event_39f798d6";
  static vapi_message_desc_t __vapi_metadata_vpncrack_decrypt_event = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_vpncrack_decrypt_event, payload),
    sizeof(vapi_msg_vpncrack_decrypt_event),
    (generic_swap_fn_t)vapi_msg_vpncrack_decrypt_event_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_decrypt_event_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_decrypt_event = vapi_register_msg(&__vapi_metadata_vpncrack_decrypt_event);
  VAPI_DBG("Assigned msg id %d to vpncrack_decrypt_event", vapi_msg_id_vpncrack_decrypt_event);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_timesync_event()
{
  static const char name[] = "vpncrack_timesync_event";
  static const char name_with_crc[] = "vpncrack_timesync_event_1474bee0";
  static vapi_message_desc_t __vapi_metadata_vpncrack_timesync_event = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_vpncrack_timesync_event, payload),
    sizeof(vapi_msg_vpncrack_timesync_event),
    (generic_swap_fn_t)vapi_msg_vpncrack_timesync_event_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_timesync_event_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_timesync_event = vapi_register_msg(&__vapi_metadata_vpncrack_timesync_event);
  VAPI_DBG("Assigned msg id %d to vpncrack_timesync_event", vapi_msg_id_vpncrack_timesync_event);
}

static void __attribute__((constructor)) __vapi_constructor_want_vpncrack_decrypt_event_reply()
{
  static const char name[] = "want_vpncrack_decrypt_event_reply";
  static const char name_with_crc[] = "want_vpncrack_decrypt_event_reply_c2d3db9f";
  static vapi_message_desc_t __vapi_metadata_want_vpncrack_decrypt_event_reply = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header1_t, context),
    offsetof(vapi_msg_want_vpncrack_decrypt_event_reply, payload),
    sizeof(vapi_msg_want_vpncrack_decrypt_event_reply),
    (generic_swap_fn_t)vapi_msg_want_vpncrack_decrypt_event_reply_hton,
    (generic_swap_fn_t)vapi_msg_want_vpncrack_decrypt_event_reply_ntoh,
    ~0,
  };

  vapi_msg_id_want_vpncrack_decrypt_event_reply = vapi_register_msg(&__vapi_metadata_want_vpncrack_decrypt_event_reply);
  VAPI_DBG("Assigned msg id %d to want_vpncrack_decrypt_event_reply", vapi_msg_id_want_vpncrack_decrypt_event_reply);
}

static void __attribute__((constructor)) __vapi_constructor_want_vpncrack_timesync_event_reply()
{
  static const char name[] = "want_vpncrack_timesync_event_reply";
  static const char name_with_crc[] = "want_vpncrack_timesync_event_reply_2f482589";
  static vapi_message_desc_t __vapi_metadata_want_vpncrack_timesync_event_reply = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header1_t, context),
    offsetof(vapi_msg_want_vpncrack_timesync_event_reply, payload),
    sizeof(vapi_msg_want_vpncrack_timesync_event_reply),
    (generic_swap_fn_t)vapi_msg_want_vpncrack_timesync_event_reply_hton,
    (generic_swap_fn_t)vapi_msg_want_vpncrack_timesync_event_reply_ntoh,
    ~0,
  };

  vapi_msg_id_want_vpncrack_timesync_event_reply = vapi_register_msg(&__vapi_metadata_want_vpncrack_timesync_event_reply);
  VAPI_DBG("Assigned msg id %d to want_vpncrack_timesync_event_reply", vapi_msg_id_want_vpncrack_timesync_event_reply);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_globle_config()
{
  static const char name[] = "vpncrack_globle_config";
  static const char name_with_crc[] = "vpncrack_globle_config_e8bc54c7";
  static vapi_message_desc_t __vapi_metadata_vpncrack_globle_config = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_vpncrack_globle_config, payload),
    sizeof(vapi_msg_vpncrack_globle_config),
    (generic_swap_fn_t)vapi_msg_vpncrack_globle_config_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_globle_config_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_globle_config = vapi_register_msg(&__vapi_metadata_vpncrack_globle_config);
  VAPI_DBG("Assigned msg id %d to vpncrack_globle_config", vapi_msg_id_vpncrack_globle_config);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_pwh_clean()
{
  static const char name[] = "vpncrack_pwh_clean";
  static const char name_with_crc[] = "vpncrack_pwh_clean_9dde852b";
  static vapi_message_desc_t __vapi_metadata_vpncrack_pwh_clean = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    ~0,
    sizeof(vapi_msg_vpncrack_pwh_clean),
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_clean_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_clean_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_pwh_clean = vapi_register_msg(&__vapi_metadata_vpncrack_pwh_clean);
  VAPI_DBG("Assigned msg id %d to vpncrack_pwh_clean", vapi_msg_id_vpncrack_pwh_clean);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_pwh_update()
{
  static const char name[] = "vpncrack_pwh_update";
  static const char name_with_crc[] = "vpncrack_pwh_update_ed22cbed";
  static vapi_message_desc_t __vapi_metadata_vpncrack_pwh_update = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_vpncrack_pwh_update, payload),
    sizeof(vapi_msg_vpncrack_pwh_update),
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_update_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_update_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_pwh_update = vapi_register_msg(&__vapi_metadata_vpncrack_pwh_update);
  VAPI_DBG("Assigned msg id %d to vpncrack_pwh_update", vapi_msg_id_vpncrack_pwh_update);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_globle_config_reply()
{
  static const char name[] = "vpncrack_globle_config_reply";
  static const char name_with_crc[] = "vpncrack_globle_config_reply_8e791ff1";
  static vapi_message_desc_t __vapi_metadata_vpncrack_globle_config_reply = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header1_t, context),
    offsetof(vapi_msg_vpncrack_globle_config_reply, payload),
    sizeof(vapi_msg_vpncrack_globle_config_reply),
    (generic_swap_fn_t)vapi_msg_vpncrack_globle_config_reply_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_globle_config_reply_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_globle_config_reply = vapi_register_msg(&__vapi_metadata_vpncrack_globle_config_reply);
  VAPI_DBG("Assigned msg id %d to vpncrack_globle_config_reply", vapi_msg_id_vpncrack_globle_config_reply);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_pwh_clean_reply()
{
  static const char name[] = "vpncrack_pwh_clean_reply";
  static const char name_with_crc[] = "vpncrack_pwh_clean_reply_14354328";
  static vapi_message_desc_t __vapi_metadata_vpncrack_pwh_clean_reply = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header1_t, context),
    offsetof(vapi_msg_vpncrack_pwh_clean_reply, payload),
    sizeof(vapi_msg_vpncrack_pwh_clean_reply),
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_clean_reply_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_clean_reply_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_pwh_clean_reply = vapi_register_msg(&__vapi_metadata_vpncrack_pwh_clean_reply);
  VAPI_DBG("Assigned msg id %d to vpncrack_pwh_clean_reply", vapi_msg_id_vpncrack_pwh_clean_reply);
}

static void __attribute__((constructor)) __vapi_constructor_vpncrack_pwh_update_reply()
{
  static const char name[] = "vpncrack_pwh_update_reply";
  static const char name_with_crc[] = "vpncrack_pwh_update_reply_91dc1e3b";
  static vapi_message_desc_t __vapi_metadata_vpncrack_pwh_update_reply = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header1_t, context),
    offsetof(vapi_msg_vpncrack_pwh_update_reply, payload),
    sizeof(vapi_msg_vpncrack_pwh_update_reply),
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_update_reply_hton,
    (generic_swap_fn_t)vapi_msg_vpncrack_pwh_update_reply_ntoh,
    ~0,
  };

  vapi_msg_id_vpncrack_pwh_update_reply = vapi_register_msg(&__vapi_metadata_vpncrack_pwh_update_reply);
  VAPI_DBG("Assigned msg id %d to vpncrack_pwh_update_reply", vapi_msg_id_vpncrack_pwh_update_reply);
}

static void __attribute__((constructor)) __vapi_constructor_want_vpncrack_timesync_event()
{
  static const char name[] = "want_vpncrack_timesync_event";
  static const char name_with_crc[] = "want_vpncrack_timesync_event_b0654c07";
  static vapi_message_desc_t __vapi_metadata_want_vpncrack_timesync_event = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_want_vpncrack_timesync_event, payload),
    sizeof(vapi_msg_want_vpncrack_timesync_event),
    (generic_swap_fn_t)vapi_msg_want_vpncrack_timesync_event_hton,
    (generic_swap_fn_t)vapi_msg_want_vpncrack_timesync_event_ntoh,
    ~0,
  };

  vapi_msg_id_want_vpncrack_timesync_event = vapi_register_msg(&__vapi_metadata_want_vpncrack_timesync_event);
  VAPI_DBG("Assigned msg id %d to want_vpncrack_timesync_event", vapi_msg_id_want_vpncrack_timesync_event);
}

static void __attribute__((constructor)) __vapi_constructor_want_vpncrack_decrypt_event()
{
  static const char name[] = "want_vpncrack_decrypt_event";
  static const char name_with_crc[] = "want_vpncrack_decrypt_event_5cf6ea23";
  static vapi_message_desc_t __vapi_metadata_want_vpncrack_decrypt_event = {
    name,
    sizeof(name) - 1,
    name_with_crc,
    sizeof(name_with_crc) - 1,
    true,
    offsetof(vapi_type_msg_header2_t, context),
    offsetof(vapi_msg_want_vpncrack_decrypt_event, payload),
    sizeof(vapi_msg_want_vpncrack_decrypt_event),
    (generic_swap_fn_t)vapi_msg_want_vpncrack_decrypt_event_hton,
    (generic_swap_fn_t)vapi_msg_want_vpncrack_decrypt_event_ntoh,
    ~0,
  };

  vapi_msg_id_want_vpncrack_decrypt_event = vapi_register_msg(&__vapi_metadata_want_vpncrack_decrypt_event);
  VAPI_DBG("Assigned msg id %d to want_vpncrack_decrypt_event", vapi_msg_id_want_vpncrack_decrypt_event);
}


static inline void vapi_set_vapi_msg_vpncrack_decrypt_event_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_vpncrack_decrypt_event *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_vpncrack_decrypt_event, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_vpncrack_timesync_event_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_vpncrack_timesync_event *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_vpncrack_timesync_event, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_want_vpncrack_decrypt_event_reply_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_want_vpncrack_decrypt_event_reply *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_want_vpncrack_decrypt_event_reply, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_want_vpncrack_timesync_event_reply_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_want_vpncrack_timesync_event_reply *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_want_vpncrack_timesync_event_reply, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_vpncrack_globle_config_reply_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_vpncrack_globle_config_reply *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_vpncrack_globle_config_reply, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_vpncrack_pwh_clean_reply_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_vpncrack_pwh_clean_reply *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_vpncrack_pwh_clean_reply, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_vpncrack_pwh_update_reply_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_vpncrack_pwh_update_reply *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_vpncrack_pwh_update_reply, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_want_vpncrack_timesync_event_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_want_vpncrack_timesync_event *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_want_vpncrack_timesync_event, (vapi_event_cb)callback, callback_ctx);
};

static inline void vapi_set_vapi_msg_want_vpncrack_decrypt_event_event_cb (
  struct vapi_ctx_s *ctx, 
  vapi_error_e (*callback)(struct vapi_ctx_s *ctx, void *callback_ctx, vapi_payload_want_vpncrack_decrypt_event *payload),
  void *callback_ctx)
{
  vapi_set_event_cb(ctx, vapi_msg_id_want_vpncrack_decrypt_event, (vapi_event_cb)callback, callback_ctx);
};


#ifdef __cplusplus
}
#endif

#endif
